@ethlete/eslint-plugin 0.1.0-next.0 → 0.1.0-next.10

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

@@ -0,0 +1,95 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows non-empty function bodies inside `.subscribe()` calls.
+ * Side effects must be moved into a `tap()` operator inside the pipe instead.
+ *
+ * ❌ someObs$.subscribe((res) => console.log(res));
+ * ❌ someObs$.subscribe((res) => { doSomething(res); });
+ * ❌ someObs$.subscribe({ next: (res) => doSomething(res) });
+ *
+ * ✅ someObs$.pipe(tap((res) => console.log(res))).subscribe();
+ * ✅ someObs$.subscribe();
+ * ✅ someObs$.subscribe(() => {});  // empty body is fine
+ *
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const rule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require subscribe() to be called with an empty body. Move side effects into tap() inside the pipe.',
+    },
+    schema: [],
+    messages: {
+      noSubscribeBody: 'Keep subscribe() empty. Move side effects into a tap() operator inside the pipe.',
+    },
+  },
+  create(context) {
+    /**
+     * Returns true if the function node has a non-empty body.
+     * @param {import('eslint').Rule.Node} fn
+     */
+    const hasBody = (fn) => {
+      const node = /** @type {any} */ (fn);
+      if (node.type === 'ArrowFunctionExpression') {
+        // Concise arrow: `(x) => x.foo` — always has a value expression
+        if (node.body.type !== 'BlockStatement') return true;
+        return node.body.body.length > 0;
+      }
+      if (node.type === 'FunctionExpression') {
+        return node.body.body.length > 0;
+      }
+      return false;
+    };
+
+    return {
+      CallExpression(node) {
+        const callee = /** @type {any} */ (node.callee);
+
+        if (
+          callee.type !== 'MemberExpression' ||
+          callee.property.type !== 'Identifier' ||
+          callee.property.name !== 'subscribe'
+        ) {
+          return;
+        }
+
+        const args = /** @type {any[]} */ (node.arguments);
+
+        // Skip non-RxJS subscribe patterns where the first argument is a string
+        // literal (e.g. Facebook SDK: player.subscribe('eventName', callback)).
+        // RxJS .subscribe() never takes a string as its first argument.
+        if (args.length > 0 && args[0].type === 'Literal' && typeof args[0].value === 'string') {
+          return;
+        }
+
+        for (const arg of args) {
+          // Direct function argument: .subscribe((res) => ...)
+          if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+            if (hasBody(arg)) {
+              context.report({ node, messageId: 'noSubscribeBody' });
+              return;
+            }
+            continue;
+          }
+
+          // 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)) {
+                context.report({ node, messageId: 'noSubscribeBody' });
+                return;
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = rule;

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

@@ -0,0 +1,104 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows trivially-inferable explicit return type annotations on function
+ * implementations. TypeScript infers `void`, `boolean`, `string`, `number`,
+ * `undefined`, and `null` without help; writing them out adds noise.
+ *
+ * BAD:  const go = (): void => { ... }
+ * GOOD: const go = () => { ... }
+ *
+ * ALSO GOOD (non-trivial, keep it):
+ *   const parse = (): Date => new Date(value)
+ */
+
+const TRIVIAL_TYPES = new Set([
+  'TSVoidKeyword',
+  'TSBooleanKeyword',
+  'TSStringKeyword',
+  'TSNumberKeyword',
+  'TSUndefinedKeyword',
+  'TSNullKeyword',
+]);
+
+const TRIVIAL_LABELS = {
+  TSVoidKeyword: 'void',
+  TSBooleanKeyword: 'boolean',
+  TSStringKeyword: 'string',
+  TSNumberKeyword: 'number',
+  TSUndefinedKeyword: 'undefined',
+  TSNullKeyword: 'null',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noTrivialReturnType = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description:
+        'Disallow explicit return type annotations that TypeScript can infer (void, boolean, string, number, undefined, null).',
+      recommended: true,
+    },
+    messages: {
+      trivialReturnType: "Omit the explicit ': {{type}}' return type — TypeScript infers it.",
+    },
+    schema: [],
+  },
+  create(context) {
+    /**
+     * Walk up the AST to detect type-level contexts (type aliases, interface bodies,
+     * abstract method signatures) where return type annotations are required / expected.
+     * @param {import('eslint').Rule.Node} node
+     */
+    const isInsideTypeContext = (node) => {
+      let current = node.parent;
+      while (current) {
+        const t = current.type;
+        // Type-level signatures — not implementations
+        if (t === 'TSTypeLiteral' || t === 'TSInterfaceBody' || t === 'TSTypeAliasDeclaration') {
+          return true;
+        }
+        // Abstract method declarations (separate AST node via @typescript-eslint/parser)
+        if (t === 'TSAbstractMethodDefinition' || t === 'TSMethodSignature') {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    };
+
+    /**
+     * @param {import('eslint').Rule.Node} node
+     */
+    const checkReturnType = (node) => {
+      // @typescript-eslint/parser adds `returnType` to function nodes at runtime
+      // even though the base ESTree type doesn't declare it.
+      const fn = /** @type {any} */ (node);
+      if (!fn.returnType) return;
+      if (isInsideTypeContext(node)) return;
+
+      const annotation = fn.returnType.typeAnnotation;
+      if (!TRIVIAL_TYPES.has(annotation.type)) return;
+
+      const label = TRIVIAL_LABELS[annotation.type] ?? annotation.type;
+
+      context.report({
+        node: fn.returnType,
+        messageId: 'trivialReturnType',
+        data: { type: label },
+        fix(fixer) {
+          return fixer.remove(fn.returnType);
+        },
+      });
+    };
+
+    return {
+      ArrowFunctionExpression: checkReturnType,
+      FunctionExpression: checkReturnType,
+    };
+  },
+};
+
+module.exports = noTrivialReturnType;

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

@@ -0,0 +1,120 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows trivial wrapper methods that do nothing but forward all their
+ * arguments to another call.
+ *
+ * These methods add an extra layer of indirection without adding any value.
+ * Call sites should invoke the target directly.
+ *
+ * BAD:
+ *   setValue(val: string) { this.value.set(val); }           // just delegates
+ *   getItem(key: string) { return this.store.get(key); }     // just delegates
+ *   doThing(a: string, b: number) { this.impl.doThing(a, b); }
+ *
+ * GOOD:
+ *   // Call this.value.set(val) directly at the call sites.
+ *   // If the method wraps something non-trivially (transforms args, adds logic), it is fine.
+ */
+
+/**
+ * Returns true when the param is a plain identifier (no default, no destructuring, no rest).
+ * @param {import('@typescript-eslint/types').TSESTree.Parameter} param
+ */
+const isSimpleParam = (param) => param.type === 'Identifier';
+
+/**
+ * Returns the single CallExpression in the method body when the method is a
+ * trivial all-args-forwarding wrapper, or null otherwise.
+ *
+ * Matches both void wrappers:
+ *   setValue(val) { this.value.set(val); }
+ * and return wrappers:
+ *   get(key) { return this.store.get(key); }
+ *
+ * @param {import('eslint').Rule.Node} methodNode  MethodDefinition node
+ * @returns {import('eslint').Rule.Node | null}
+ */
+const getTrivialCallExpr = (methodNode) => {
+  const fnValue = methodNode.value;
+  if (!fnValue) return null;
+
+  const params = fnValue.params;
+  // Require at least one parameter — zero-param delegate methods are deliberate API surface.
+  if (params.length === 0) return null;
+  // All params must be simple identifiers (no destructuring, defaults, or rest).
+  if (!params.every(isSimpleParam)) return null;
+
+  const body = fnValue.body;
+  if (!body || body.type !== 'BlockStatement') return null;
+  if (body.body.length !== 1) return null;
+
+  const stmt = body.body[0];
+
+  let callExpr = null;
+  if (stmt.type === 'ExpressionStatement') {
+    callExpr = stmt.expression;
+  } else if (stmt.type === 'ReturnStatement' && stmt.argument) {
+    callExpr = stmt.argument;
+  }
+
+  if (!callExpr || callExpr.type !== 'CallExpression') return null;
+  if (callExpr.arguments.length !== params.length) return null;
+
+  // All arguments must be the method's own param names in the same order.
+  const allMatch = params.every((param, i) => {
+    const arg = callExpr.arguments[i];
+    return arg.type === 'Identifier' && arg.name === param.name;
+  });
+
+  return allMatch ? callExpr : null;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noTrivialWrapperMethod = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow trivial wrapper methods that only forward all arguments to another call.',
+      recommended: true,
+    },
+    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.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      MethodDefinition(node) {
+        // Skip constructors, getters, and setters — they commonly delegate for good reasons.
+        if (node.kind === 'constructor' || node.kind === 'get' || node.kind === 'set') return;
+
+        const callExpr = getTrivialCallExpr(node);
+        if (!callExpr) return;
+
+        const methodName = node.key.type === 'Identifier' ? node.key.name : null;
+        if (!methodName) return;
+
+        const callee = callExpr.callee;
+        const targetName =
+          callee.type === 'MemberExpression'
+            ? context.sourceCode.getText(callee)
+            : callee.type === 'Identifier'
+              ? callee.name
+              : null;
+
+        if (!targetName) return;
+
+        context.report({
+          node,
+          messageId: 'noTrivialWrapperMethod',
+          data: { name: methodName, target: targetName },
+        });
+      },
+    };
+  },
+};
+
+module.exports = noTrivialWrapperMethod;

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

@@ -0,0 +1,79 @@
+// @ts-check
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noTypeOnlyImport = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow `import type { Foo }` and `import { type Foo }` — use a regular value import instead.',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      noTypeImportDeclaration:
+        "Do not use `import type`. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+      noInlineTypeSpecifier:
+        "Do not use inline `type` on import specifiers. Use a regular import instead: `import { {{specifiers}} } from '{{source}}';`.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      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 },
+            fix(fixer) {
+              const specifierText = node.specifiers.map((s) => s.local.name).join(', ');
+              return fixer.replaceText(node, `import { ${specifierText} } from '${source}';`);
+            },
+          });
+
+          return;
+        }
+
+        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 },
+              fix(fixer) {
+                const sourceCode = context.sourceCode;
+                const tokenBefore = sourceCode.getTokenBefore(specifier.imported ?? specifier.local);
+                if (tokenBefore && tokenBefore.value === 'type') {
+                  const tokenAfter = sourceCode.getTokenAfter(tokenBefore);
+                  if (tokenAfter) {
+                    return fixer.removeRange([tokenBefore.range[0], tokenAfter.range[0]]);
+                  }
+                }
+                return null;
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = noTypeOnlyImport;

package/src/rules/no-typed-injected-element-ref.js

@@ -0,0 +1,88 @@
+// @ts-check
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noTypedInjectedElementRef = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require that inject(ElementRef) uses a generic type parameter on inject() itself, not on ElementRef.',
+      recommended: true,
+    },
+    messages: {
+      missingGeneric:
+        'Provide a generic type on inject() itself: `inject<ElementRef<HTMLElement>>(ElementRef)`. Passing a type argument on ElementRef directly is also disallowed.',
+    },
+    schema: [],
+    fixable: 'code',
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+        if (!firstArg) return;
+
+        const isPlainElementRef = firstArg.type === 'Identifier' && firstArg.name === 'ElementRef';
+        const isInstantiatedElementRef =
+          firstArg.type === 'TSInstantiationExpression' &&
+          firstArg.expression &&
+          firstArg.expression.type === 'Identifier' &&
+          firstArg.expression.name === 'ElementRef';
+
+        if (!isPlainElementRef && !isInstantiatedElementRef) return;
+
+        const src = context.sourceCode;
+        const existingTypeParams = node.typeParameters || node.typeArguments;
+        const hasInjectTypeParam =
+          existingTypeParams && existingTypeParams.params && existingTypeParams.params.length > 0;
+
+        if (isPlainElementRef && !hasInjectTypeParam) {
+          // inject(ElementRef) → inject<ElementRef<HTMLElement>>(ElementRef)
+          context.report({
+            node,
+            messageId: 'missingGeneric',
+            fix(fixer) {
+              return fixer.insertTextAfter(node.callee, '<ElementRef<HTMLElement>>');
+            },
+          });
+          return;
+        }
+
+        if (isInstantiatedElementRef) {
+          // Capture the type args text from the token, e.g. "<HTMLElement>"
+          const tokenTypeParamText = src.getText(firstArg.typeParameters || firstArg.typeArguments);
+
+          if (!hasInjectTypeParam) {
+            // 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'),
+                ];
+              },
+            });
+          } else {
+            // inject<X>(ElementRef<Y>) — token must not carry type args; keep inject's type param
+            context.report({
+              node,
+              messageId: 'missingGeneric',
+              fix(fixer) {
+                return fixer.replaceText(firstArg, 'ElementRef');
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = noTypedInjectedElementRef;

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

@@ -0,0 +1,209 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows class members that are declared but never read 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.
+ *
+ * - `protected` members — checked only when the class has an Angular decorator
+ *   other than `@Component` (i.e. `@Directive`, `@Pipe`, `@Injectable`).
+ *   For `@Component`, protected members may be read in the HTML template file
+ *   which is invisible to static analysis, so protected is skipped there.
+ *   For plain (non-Angular) classes, protected members may be used in a
+ *   subclass in another file, so they are also skipped.
+ *
+ * Members referenced in `host:` binding expressions in the class decorator are
+ * excluded from the check for `protected` (since they are accessed by Angular
+ * at runtime via the host binding mechanism).
+ *
+ * BAD:
+ *   private document = inject(DOCUMENT); // fetched but never used
+ *   private unusedFlag = false;
+ *
+ * GOOD:
+ *   private document = inject(DOCUMENT);
+ *   createElement() { return this.document.createElement('div'); }
+ */
+
+const ANGULAR_DECORATORS = new Set(['Component', 'Directive', 'Pipe', 'Injectable']);
+
+/**
+ * Extract all identifier-like tokens from a template expression string.
+ * Used for `host:` binding values like `'myMember ? "on" : "off"'`.
+ * @param {string} str
+ * @returns {string[]}
+ */
+const extractIdentifiers = (str) => str.match(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g) ?? [];
+
+/**
+ * Returns info about the Angular decorators applied to a class node.
+ * @param {any} classNode
+ * @returns {{ isComponent: boolean, isAngularClass: boolean }}
+ */
+const getDecoratorInfo = (classNode) => {
+  const decorators = classNode.decorators ?? [];
+  let isComponent = false;
+  let isAngularClass = false;
+
+  for (const dec of decorators) {
+    const expr = dec.expression;
+    const name =
+      expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier'
+        ? expr.callee.name
+        : expr?.type === 'Identifier'
+          ? expr.name
+          : null;
+
+    if (name && ANGULAR_DECORATORS.has(name)) {
+      isAngularClass = true;
+      if (name === 'Component') isComponent = true;
+    }
+  }
+
+  return { isComponent, isAngularClass };
+};
+
+/**
+ * Returns names of class members referenced in `host:` binding value strings
+ * found in any decorator argument on the class.
+ * @param {any} classNode
+ * @returns {Set<string>}
+ */
+const getHostBoundMembers = (classNode) => {
+  /** @type {Set<string>} */
+  const result = new Set();
+  const decorators = classNode.decorators ?? [];
+
+  for (const dec of decorators) {
+    const expr = dec.expression;
+    if (expr?.type !== 'CallExpression') continue;
+
+    const arg = expr.arguments?.[0];
+    if (!arg || arg.type !== 'ObjectExpression') continue;
+
+    const hostProp = arg.properties.find(
+      /** @param {any} p */
+      (p) => p.type === 'Property' && (p.key?.name === 'host' || p.key?.value === 'host'),
+    );
+    if (!hostProp || hostProp.value?.type !== 'ObjectExpression') continue;
+
+    for (const binding of hostProp.value.properties) {
+      if (binding.type !== 'Property') continue;
+      /** @type {any} */
+      const val = binding.value;
+      if (val?.type !== 'Literal' || typeof val.value !== 'string') continue;
+      for (const id of extractIdentifiers(val.value)) result.add(id);
+    }
+  }
+
+  return result;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noUnusedClassMember = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow class members that are declared but never read within the class body.',
+      recommended: true,
+    },
+    messages: {
+      noUnused:
+        "'{{name}}' is declared but its value is never read within this class. " +
+        'Remove it, or widen its accessibility if it is intentionally used externally.',
+    },
+    schema: [],
+  },
+  create(context) {
+    /**
+     * Stack of class frames. Each frame tracks which members are candidates and
+     * which have been seen in a `this.x` expression.
+     *
+     * @type {Array<{
+     *   classBody: import('eslint').Rule.Node,
+     *   isComponent: boolean,
+     *   isAngularClass: boolean,
+     *   hostBound: Set<string>,
+     *   candidates: Map<string, import('eslint').Rule.Node>,
+     *   usedNames: Set<string>,
+     * }>}
+     */
+    const classStack = [];
+
+    /**
+     * @param {any} node
+     */
+    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;
+
+      const key = node.key;
+      if (!key || key.type !== 'Identifier') return;
+      if (node.type === 'MethodDefinition' && node.kind === 'constructor') return;
+
+      const name = key.name;
+      const accessibility = node.accessibility;
+      const { isComponent, isAngularClass, hostBound } = frame;
+
+      if (accessibility === 'private') {
+        frame.candidates.set(name, node);
+      } else if (accessibility === 'protected' && isAngularClass && !isComponent) {
+        if (!hostBound.has(name)) frame.candidates.set(name, node);
+      }
+    };
+
+    return {
+      ClassBody(node) {
+        const classNode = node.parent;
+        const { isComponent, isAngularClass } = getDecoratorInfo(classNode);
+        const hostBound = getHostBoundMembers(classNode);
+        classStack.push({
+          classBody: node,
+          isComponent,
+          isAngularClass,
+          hostBound,
+          candidates: new Map(),
+          usedNames: new Set(),
+        });
+      },
+
+      'ClassBody:exit'() {
+        const frame = classStack.pop();
+        if (!frame) return;
+        for (const [name, memberNode] of frame.candidates) {
+          if (!frame.usedNames.has(name)) {
+            context.report({ node: memberNode, messageId: 'noUnused', data: { name } });
+          }
+        }
+      },
+
+      PropertyDefinition: registerMember,
+      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;
+
+        // 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);
+      },
+    };
+  },
+};
+
+module.exports = noUnusedClassMember;