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

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

@@ -0,0 +1,95 @@
+// @ts-check
+'use strict';
+
+/** @typedef {'Component' | 'Directive' | 'Pipe'} TDecoratorName */
+
+/**
+ * @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').Rule.Node} node
+ * @returns {TDecoratorName | null}
+ */
+const getDecoratorName = (node) => {
+  const decorator = /** @type {any} */ (node);
+  if (decorator.type !== 'Decorator') return null;
+
+  const expression = decorator.expression;
+  if (expression.type === 'CallExpression') {
+    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
+  }
+
+  return expression.type === 'Identifier' ? expression.name : null;
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} metadata
+ * @param {any} property
+ */
+const getRemovalRange = (sourceCode, metadata, property) => {
+  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
+  const propertyIndex = properties.indexOf(property);
+  const openingBrace = sourceCode.getFirstToken(metadata);
+  const closingBrace = sourceCode.getLastToken(metadata);
+
+  if (!openingBrace || !closingBrace) return property.range;
+  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
+  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
+
+  return [properties[propertyIndex - 1].range[1], property.range[1]];
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noStandaloneFlag = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow standalone metadata on Angular decorators because standalone is the default and should be omitted.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noStandalone: 'Remove standalone from Angular metadata. Standalone is implicit and should not be declared.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      Decorator(node) {
+        const decoratorName = getDecoratorName(node);
+        if (decoratorName !== 'Component' && decoratorName !== 'Directive' && decoratorName !== 'Pipe') return;
+
+        const decorator = /** @type {any} */ (node);
+        const expression = decorator.expression;
+        if (expression.type !== 'CallExpression' || expression.arguments.length === 0) return;
+
+        const metadata = expression.arguments[0];
+        if (!metadata || metadata.type !== 'ObjectExpression') return;
+
+        for (const property of metadata.properties) {
+          if (property.type !== 'Property') continue;
+          if (getPropertyName(property.key) !== 'standalone') continue;
+
+          context.report({
+            node: property,
+            messageId: 'noStandalone',
+            fix(fixer) {
+              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noStandaloneFlag;

package/src/rules/no-subscribe-in-pipe.js

@@ -0,0 +1,89 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows calling .subscribe() inside a .pipe() callback.
+ *
+ * BAD:
+ *   obs$.pipe(
+ *     tap(() => {
+ *       other$.subscribe(); // ❌ creates an unmanaged subscription
+ *     }),
+ *   ).subscribe();
+ *
+ * GOOD:
+ *   obs$.pipe(
+ *     switchMap(() => other$), // ✅ compose instead
+ *   ).subscribe();
+ *
+ *   obs$.pipe(...operators).subscribe(); // ✅ subscribe on the result of pipe
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noSubscribeInPipe = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow .subscribe() calls inside .pipe() callbacks.',
+      recommended: true,
+    },
+    messages: {
+      noSubscribeInPipe:
+        'Avoid calling .subscribe() inside a .pipe() callback. Compose with operators (switchMap, mergeMap, etc.) instead.',
+    },
+    schema: [],
+  },
+  create(context) {
+    /**
+     * Returns true if the given node is nested inside a callback function that
+     * is itself (directly or indirectly) an argument to a .pipe() call.
+     * @param {import('eslint').Rule.Node} node
+     */
+    const isInsidePipeCallback = (node) => {
+      let crossedFunctionBoundary = false;
+      let current = node.parent;
+      while (current) {
+        // A `new Observable(factory)` is its own subscription boundary — subscribing
+        // inside it is intentional (inner subscription management) and should not
+        // be flagged even if the Observable itself is passed into a .pipe() operator.
+        if (
+          current.type === 'NewExpression' &&
+          current.callee.type === 'Identifier' &&
+          current.callee.name === 'Observable'
+        ) {
+          return false;
+        }
+        if (current.type === 'ArrowFunctionExpression' || current.type === 'FunctionExpression') {
+          crossedFunctionBoundary = true;
+        }
+        if (
+          crossedFunctionBoundary &&
+          current.type === 'CallExpression' &&
+          current.callee.type === 'MemberExpression' &&
+          current.callee.property.type === 'Identifier' &&
+          current.callee.property.name === 'pipe'
+        ) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    };
+
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (
+          callee.type === 'MemberExpression' &&
+          callee.property.type === 'Identifier' &&
+          callee.property.name === 'subscribe' &&
+          isInsidePipeCallback(node)
+        ) {
+          context.report({ node, messageId: 'noSubscribeInPipe' });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noSubscribeInPipe;

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;