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

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

@@ -17,6 +17,8 @@ const { getAngularDecoratorName } = require('./internals/import-resolution');
  *
  * GOOD:
  *   // Call this.value.set(val) directly at the call sites.
+ *   // A public method over a private/protected member is the encapsulation, not a wrapper:
+ *   //   private items = signal([]); setItems(items) { this.items.set(items); }
  *   // If the method wraps something non-trivially (transforms args, adds logic), it is fine.
  *   // `focus`/`blur`/`reset` on a @Component/@Directive are exempt - see CONTRACT_METHOD_NAMES.
  */
@@ -92,6 +94,39 @@ const getTrivialCallExpr = (methodNode) => {
   return allMatch ? callExpr : null;
 };
 
+/** @param {any} member */
+const visibilityOf = (member) => {
+  if (member.key?.type === 'PrivateIdentifier' || member.accessibility === 'private') return 0;
+  if (member.accessibility === 'protected') return 1;
+  return 2;
+};
+
+/**
+ * @param {any} classBody
+ * @param {any} callee
+ */
+const receiverVisibility = (classBody, callee) => {
+  let object = callee;
+  while (object.type === 'MemberExpression' && object.object.type !== 'ThisExpression') object = object.object;
+  if (object.type !== 'MemberExpression' || object.computed) return undefined;
+
+  const name = object.property.type === 'PrivateIdentifier' ? `#${object.property.name}` : object.property.name;
+  /** @param {any} key */
+  const keyName = (key) => (key?.type === 'PrivateIdentifier' ? `#${key.name}` : key?.name);
+
+  for (const member of classBody.body) {
+    if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
+      const property = member.value.params.find(
+        (/** @type {any} */ param) => param.type === 'TSParameterProperty' && param.parameter.name === name,
+      );
+      if (property) return visibilityOf(property);
+      continue;
+    }
+    if (keyName(member.key) === name) return visibilityOf(member);
+  }
+  return undefined;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTrivialWrapperMethod = {
   meta: {
@@ -102,7 +137,7 @@ const noTrivialWrapperMethod = {
     },
     messages: {
       noTrivialWrapperMethod:
-        "'{{name}}' is a trivial wrapper — it only forwards all its arguments to '{{target}}'. Remove it and call '{{target}}' directly at each call site.",
+        "'{{name}}' is a trivial wrapper — it only forwards all its arguments to '{{target}}', which callers can already reach. Remove it and call '{{target}}' directly at each call site.",
     },
     schema: [],
   },
@@ -133,6 +168,9 @@ const noTrivialWrapperMethod = {
 
         if (!targetName) return;
 
+        const wrapped = receiverVisibility(node.parent, callee);
+        if (wrapped !== undefined && visibilityOf(node) > wrapped) return;
+
         context.report({
           node,
           messageId: 'noTrivialWrapperMethod',

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

@@ -1,6 +1,25 @@
 // @ts-check
 'use strict';
 
+/** @param {any} node */
+const renderValueImport = (node) => {
+  const clauses = [];
+  const named = [];
+
+  for (const s of node.specifiers) {
+    if (s.type === 'ImportDefaultSpecifier') clauses.push(s.local.name);
+    else if (s.type === 'ImportNamespaceSpecifier') clauses.push(`* as ${s.local.name}`);
+    else {
+      const imported = s.imported.type === 'Identifier' ? s.imported.name : `'${s.imported.value}'`;
+      named.push(s.local.name === imported ? imported : `${imported} as ${s.local.name}`);
+    }
+  }
+
+  if (named.length) clauses.push(`{ ${named.join(', ')} }`);
+
+  return `import ${clauses.join(', ')} from '${node.source.value}';`;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTypeOnlyImport = {
   meta: {
@@ -11,10 +30,9 @@ const noTypeOnlyImport = {
     },
     fixable: 'code',
     messages: {
-      noTypeImportDeclaration:
-        "Do not use `import type`. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+      noTypeImportDeclaration: 'Do not use `import type`. Use a regular import instead: `{{replacement}}`.',
       noInlineTypeSpecifier:
-        "Do not use inline `type` on import specifiers. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+        'Do not use inline `type` on import specifiers. Use a regular import instead: `{{replacement}}`.',
     },
     schema: [],
   },
@@ -23,13 +41,10 @@ const noTypeOnlyImport = {
       ImportDeclaration(node) {
         const decl = /** @type {any} */ (node);
         if (decl.importKind === 'type') {
-          const source = /** @type {string} */ (node.source.value);
-          const specifiers = node.specifiers.map((s) => s.local.name).join(', ');
-
           context.report({
             node,
             messageId: 'noTypeImportDeclaration',
-            data: { specifiers, source },
+            data: { replacement: renderValueImport(node) },
             fix(fixer) {
               const sourceCode = context.sourceCode;
               const importToken = sourceCode.getFirstToken(node);
@@ -47,21 +62,10 @@ const noTypeOnlyImport = {
         for (const specifier of node.specifiers) {
           const spec = /** @type {any} */ (specifier);
           if (specifier.type === 'ImportSpecifier' && spec.importKind === 'type') {
-            const source = /** @type {string} */ (node.source.value);
-            const allSpecifiers = node.specifiers
-              .map((s) => {
-                if (s.type === 'ImportSpecifier') {
-                  const imported = s.imported.type === 'Identifier' ? s.imported.name : s.imported.value;
-                  return s.local.name === imported ? imported : `${imported} as ${s.local.name}`;
-                }
-                return s.local.name;
-              })
-              .join(', ');
-
             context.report({
               node: specifier,
               messageId: 'noInlineTypeSpecifier',
-              data: { specifiers: allSpecifiers, source },
+              data: { replacement: renderValueImport(node) },
               fix(fixer) {
                 const sourceCode = context.sourceCode;
                 const tokenBefore = sourceCode.getTokenBefore(specifier.imported ?? specifier.local);

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

@@ -4,13 +4,13 @@
 const { getAngularDecoratorName } = require('./internals/import-resolution');
 
 /**
- * Disallows class members that are declared but never read within the class body.
+ * Disallows class members that are declared but never referenced through `this` within the class body.
  *
  * Only checks members that CANNOT be accessed from outside the class at compile
  * time — so false positives (e.g. template usage) are avoided:
  *
  * - `private` members — always checked. Private members are only accessible
- *   within the class body, so if they are never read there they are dead code.
+ *   within the class body, so if they are never referenced there they are dead code.
  *
  * - `protected` members — checked only when the class has an Angular decorator
  *   other than `@Component` (i.e. `@Directive`, `@Pipe`, `@Injectable`).
@@ -106,13 +106,17 @@ const noUnusedClassMember = {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Disallow class members that are declared but never read within the class body.',
+      description:
+        'Disallow class members that are declared but never referenced through `this` within the class body.',
       recommended: true,
     },
     messages: {
       noUnused:
-        "'{{name}}' is declared but its value is never read within this class. " +
+        "'{{name}}' is declared but never referenced through `this` within this class. " +
         'Remove it, or widen its accessibility if it is intentionally used externally.',
+      noUnusedProtected:
+        "'{{name}}' is protected but never referenced through `this` within this class. " +
+        'If a subclass reads it, mark this class `abstract`; otherwise remove it.',
     },
     schema: [],
   },
@@ -139,7 +143,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;
@@ -182,13 +185,18 @@ const noUnusedClassMember = {
         if (!frame) return;
         for (const [name, memberNode] of frame.candidates) {
           if (!frame.usedNames.has(name)) {
-            context.report({ node: memberNode, messageId: 'noUnused', data: { name } });
+            context.report({
+              node: memberNode,
+              messageId: memberNode.accessibility === 'protected' ? 'noUnusedProtected' : 'noUnused',
+              data: { name },
+            });
           }
         }
       },
 
       PropertyDefinition: registerMember,
       MethodDefinition: registerMember,
+      AccessorProperty: registerMember,
 
       MemberExpression(node) {
         if (node.object?.type !== 'ThisExpression') return;

package/src/rules/no-window-location.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /**
  * Disallows reading URL state from window.location properties.
  *
@@ -52,29 +54,55 @@ const noWindowLocation = {
     schema: [],
   },
   create(context) {
+    const isGlobalObject = (node) =>
+      node.type === 'Identifier' &&
+      (node.name === 'window' || node.name === 'globalThis') &&
+      isGlobalReference(context.sourceCode, node);
+
+    const findVariable = (identifier) => {
+      for (let scope = context.sourceCode.getScope(identifier); scope; scope = scope.upper) {
+        const variable = scope.set.get(identifier.name);
+        if (variable) return variable;
+      }
+
+      return null;
+    };
+
+    const isLocation = (node) => {
+      if (node.type === 'Identifier') {
+        if (node.name === 'location' && isGlobalReference(context.sourceCode, node)) return true;
+
+        const definitions = findVariable(node)?.defs ?? [];
+
+        return (
+          definitions.length === 1 &&
+          definitions[0].type === 'Variable' &&
+          definitions[0].node.id.type === 'Identifier' &&
+          definitions[0].parent.kind === 'const' &&
+          !!definitions[0].node.init &&
+          isLocation(definitions[0].node.init)
+        );
+      }
+
+      return (
+        node.type === 'MemberExpression' &&
+        !node.computed &&
+        isGlobalObject(node.object) &&
+        node.property.type === 'Identifier' &&
+        node.property.name === 'location'
+      );
+    };
+
     return {
-      // ── window.location.{prop} reads ────────────────────────────────────────
       MemberExpression(node) {
-        if (node.property.type !== 'Identifier') return;
+        if (node.property.type !== 'Identifier' || node.computed) return;
         const prop = node.property.name;
 
         if (!LOCATION_STATE_PROPS.has(prop)) return;
+        if (!isLocation(node.object)) return;
 
-        // Must be window.location.{prop} — check the object is window.location
-        const parent = node.object;
-        if (
-          parent.type !== 'MemberExpression' ||
-          parent.object.type !== 'Identifier' ||
-          parent.object.name !== 'window' ||
-          parent.property.type !== 'Identifier' ||
-          parent.property.name !== 'location'
-        ) {
-          return;
-        }
-
-        // Skip assignments TO window.location.href (navigation redirect)
         if (prop === 'href' && node.parent.type === 'AssignmentExpression' && node.parent.left === node) {
-          return;
+          if (node.parent.operator === '=') return;
         }
 
         context.report({
@@ -84,18 +112,28 @@ const noWindowLocation = {
         });
       },
 
-      // ── new URLSearchParams(window.location.search) ─────────────────────────
+      VariableDeclarator(node) {
+        if (node.id.type !== 'ObjectPattern' || !node.init || !isLocation(node.init)) return;
+
+        for (const property of node.id.properties) {
+          if (property.type !== 'Property' || property.computed || property.key.type !== 'Identifier') continue;
+          if (!LOCATION_STATE_PROPS.has(property.key.name)) continue;
+
+          context.report({
+            node: property,
+            messageId: 'noWindowLocation',
+            data: { prop: property.key.name, replacement: LOCATION_STATE_PROPS.get(property.key.name) },
+          });
+        }
+      },
+
       NewExpression(node) {
         if (node.callee.type !== 'Identifier' || node.callee.name !== 'URLSearchParams') return;
         const arg = node.arguments[0];
         if (!arg) return;
         if (
           arg.type === 'MemberExpression' &&
-          arg.object.type === 'MemberExpression' &&
-          arg.object.object.type === 'Identifier' &&
-          arg.object.object.name === 'window' &&
-          arg.object.property.type === 'Identifier' &&
-          arg.object.property.name === 'location' &&
+          isLocation(arg.object) &&
           arg.property.type === 'Identifier' &&
           arg.property.name === 'search'
         ) {

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

@@ -25,7 +25,20 @@
  *   import { clone, equal } from '@ethlete/core';
  */
 
-const { MODULE_REFERENCE_SELECTOR, getModuleReference, isGlobalReference } = require('./internals/import-resolution');
+const {
+  MODULE_REFERENCE_SELECTOR,
+  getModuleReference,
+  isGlobalReference,
+  resolveIdentifier,
+} = require('./internals/import-resolution');
+
+const LODASH_SOURCES = new Set(['lodash', 'lodash-es']);
+
+/** @type {Record<string, { messageId: 'preferClone' | 'preferEqual'; method: string }>} */
+const LODASH_METHODS = {
+  cloneDeep: { messageId: 'preferClone', method: 'lodash cloneDeep' },
+  isEqual: { messageId: 'preferEqual', method: 'isEqual' },
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 const preferCloneEqual = {
@@ -49,7 +62,43 @@ const preferCloneEqual = {
       CallExpression(node) {
         const { callee } = node;
 
-        // ── JSON.parse(JSON.stringify(expr)) ─────────────────────────────────
+        if (
+          callee.type === 'MemberExpression' &&
+          !callee.computed &&
+          callee.object.type === 'Identifier' &&
+          callee.property.type === 'Identifier' &&
+          Object.hasOwn(LODASH_METHODS, callee.property.name)
+        ) {
+          const resolved = resolveIdentifier(context.sourceCode, callee.object);
+          if (
+            resolved?.source &&
+            LODASH_SOURCES.has(resolved.source) &&
+            (resolved.name === '*' || resolved.name === 'default')
+          ) {
+            const { messageId, method } = LODASH_METHODS[callee.property.name];
+            context.report({ node, messageId, data: { method } });
+            return;
+          }
+        }
+
+        if (
+          isGlobalReference(context.sourceCode, callee) &&
+          callee.name === 'require' &&
+          node.arguments[0]?.type === 'Literal' &&
+          LODASH_SOURCES.has(String(node.arguments[0].value))
+        ) {
+          const { parent } = node;
+          const method =
+            parent.type === 'MemberExpression' && parent.object === node && parent.property.type === 'Identifier'
+              ? parent.property.name
+              : null;
+          if (method && Object.hasOwn(LODASH_METHODS, method)) {
+            const { messageId, method: label } = LODASH_METHODS[method];
+            context.report({ node, messageId, data: { method: label } });
+          }
+          return;
+        }
+
         if (
           callee.type === 'MemberExpression' &&
           callee.object.type === 'Identifier' &&
@@ -71,7 +120,6 @@ const preferCloneEqual = {
           }
         }
 
-        // ── structuredClone(expr) ─────────────────────────────────────────────
         if (isGlobalReference(context.sourceCode, callee) && callee.name === 'structuredClone') {
           context.report({ node, messageId: 'preferClone', data: { method: 'structuredClone()' } });
         }
@@ -82,9 +130,6 @@ const preferCloneEqual = {
         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 { name } of reference.named) {
             if (name === 'cloneDeep') {
@@ -96,13 +141,21 @@ const preferCloneEqual = {
           return;
         }
 
-        // import cloneDeep from 'lodash/cloneDeep'
+        if (src === 'lodash.clonedeep') {
+          context.report({ node, messageId: 'preferClone', data: { method: 'lodash cloneDeep' } });
+          return;
+        }
+
+        if (src === 'lodash.isequal') {
+          context.report({ node, messageId: 'preferEqual', data: { method: 'isEqual' } });
+          return;
+        }
+
         if (src === 'lodash/cloneDeep' || src === 'lodash-es/cloneDeep') {
           context.report({ node, messageId: 'preferClone', data: { method: 'lodash cloneDeep' } });
           return;
         }
 
-        // import isEqual from 'lodash/isEqual'
         if (src === 'lodash/isEqual' || src === 'lodash-es/isEqual') {
           context.report({ node, messageId: 'preferEqual', data: { method: 'isEqual' } });
         }

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

@@ -7,7 +7,7 @@ const { getAngularDecoratorName } = require('./internals/import-resolution');
 /** @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 {{ bodyText: string; hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; trailingText: string }} TPropertyEntry */
+/** @typedef {{ bodyText: string; endsWithLineComment: boolean; hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; trailingText: string }} TPropertyEntry */
 
 const HOST_DIRECTIVE_PROPERTY_ORDER = ['directive', 'inputs', 'outputs'];
 
@@ -20,6 +20,24 @@ const getPropertyName = (key) => {
   return null;
 };
 
+/**
+ * @param {any} node
+ */
+const unwrapTypeAssertions = (node) => {
+  let current = node;
+
+  while (
+    current &&
+    (current.type === 'TSAsExpression' ||
+      current.type === 'TSSatisfiesExpression' ||
+      current.type === 'TSNonNullExpression')
+  ) {
+    current = current.expression;
+  }
+
+  return current;
+};
+
 /**
  * @param {TDecoratorName} decoratorName
  * @param {import('estree').Node} node
@@ -35,9 +53,10 @@ const getHostDirectivesArray = (decoratorName, node) => {
   for (const property of metadata.properties) {
     if (!property || property.type !== 'Property') continue;
     if (getPropertyName(property.key) !== 'hostDirectives') continue;
-    if (property.value.type !== 'ArrayExpression') return null;
+    const value = unwrapTypeAssertions(property.value);
+    if (value.type !== 'ArrayExpression') return null;
 
-    return /** @type {TArrayExpressionNode} */ (property.value);
+    return /** @type {TArrayExpressionNode} */ (value);
   }
 
   return null;
@@ -66,6 +85,11 @@ const getHostDirectiveConfigProperties = (node) => {
   return properties;
 };
 
+/**
+ * @param {string} text
+ */
+const startsWithLineBreak = (text) => /^\s*/.exec(text)?.[0].includes('\n') ?? false;
+
 /**
  * @param {TObjectExpressionNode} node
  * @param {import('eslint').SourceCode} sourceCode
@@ -98,6 +122,7 @@ const buildSortedObjectText = (node, sourceCode) => {
 
       return {
         bodyText,
+        endsWithLineComment: trailingComment?.type === 'Line',
         hasComma: Boolean(comma),
         originalIndex,
         orderIndex: orderIndexMap.get(getPropertyName(property.key)) ?? HOST_DIRECTIVE_PROPERTY_ORDER.length,
@@ -120,10 +145,12 @@ const buildSortedObjectText = (node, sourceCode) => {
   return (
     '{' +
     sortedEntries
-      .map(
-        (entry, index) =>
-          `${entry.bodyText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}${entry.trailingText}`,
-      )
+      .map((entry, index) => {
+        const followingText = sortedEntries[index + 1]?.bodyText ?? suffix;
+        const needsLineBreak = entry.endsWithLineComment && !startsWithLineBreak(followingText);
+
+        return `${entry.bodyText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}${entry.trailingText}${needsLineBreak ? '\n' : ''}`;
+      })
       .join('') +
     suffix +
     '}'
@@ -181,9 +208,10 @@ const preferConciseAngularHostDirectives = {
         if (!hostDirectives) return;
 
         for (const element of hostDirectives.elements) {
-          if (!element || element.type !== 'ObjectExpression') continue;
+          const unwrapped = unwrapTypeAssertions(element);
+          if (!unwrapped || unwrapped.type !== 'ObjectExpression') continue;
 
-          const config = /** @type {TObjectExpressionNode} */ (element);
+          const config = /** @type {TObjectExpressionNode} */ (unwrapped);
           const properties = getHostDirectiveConfigProperties(config);
           if (!properties) continue;
 
@@ -191,12 +219,12 @@ const preferConciseAngularHostDirectives = {
             const directiveValue = getDirectiveValueNode(config);
             if (!directiveValue) continue;
 
-            const hasComments = sourceCode.getCommentsInside(config).length > 0;
+            const hasComments = sourceCode.getCommentsInside(element).length > 0;
 
             context.report({
               node: config,
               messageId: 'preferShorthand',
-              fix: hasComments ? null : (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
+              fix: hasComments ? null : (fixer) => fixer.replaceText(element, sourceCode.getText(directiveValue)),
             });
 
             continue;

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

@@ -20,9 +20,16 @@ const getPropertyName = (key) => {
  * @returns {import('estree').Expression | null}
  */
 const getSingleArrayElement = (property) => {
-  if (property.value.type !== 'ArrayExpression' || property.value.elements.length !== 1) return null;
+  /** @type {any} */
+  let value = property.value;
 
-  const firstElement = /** @type {TArrayElement} */ (property.value.elements[0]);
+  while (value.type === 'TSAsExpression' || value.type === 'TSSatisfiesExpression') {
+    value = value.expression;
+  }
+
+  if (value.type !== 'ArrayExpression' || value.elements.length !== 1) return null;
+
+  const firstElement = /** @type {TArrayElement} */ (value.elements[0]);
   if (!firstElement || firstElement.type === 'SpreadElement') return null;
 
   return firstElement;
@@ -35,6 +42,7 @@ const preferConciseAngularStyleMetadata = {
     docs: {
       description:
         'Prefer `styleUrl` over single-item `styleUrls`, and avoid wrapping a single `styles` entry in an array.',
+      recommended: true,
     },
     fixable: 'code',
     messages: {