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

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

@@ -0,0 +1,119 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows `readonly` on class properties initialized with reactive Angular/RxJS APIs.
+ *
+ * The `readonly` modifier on a signal, input, computed, or inject() call is misleading —
+ * the "readonly" constraint applies to the reference (you can't reassign the property),
+ * but the underlying value is mutable. It also prevents common patterns like
+ * resetting or swapping the signal.
+ *
+ * BAD:
+ *   readonly mySignal = signal(false);
+ *   readonly myInput = input(false);
+ *   readonly myComputed = computed(() => this.x() + 1);
+ *   readonly myService = inject(MyService);
+ *
+ * GOOD (constants that truly never change):
+ *   readonly MAX_ITEMS = 100;
+ *   readonly PLATFORM = inject(PLATFORM_ID);   // ← still a violation; assign without readonly
+ *
+ * GOOD (actual usage):
+ *   mySignal = signal(false);
+ *   myInput = input(false);
+ *   myComputed = computed(() => this.x() + 1);
+ *   private myService = inject(MyService);
+ */
+
+/**
+ * Names of Angular/RxJS reactive APIs that should never be marked `readonly`.
+ */
+const REACTIVE_APIS = new Set([
+  // Angular signals
+  'signal',
+  'computed',
+  'linkedSignal',
+  // Angular models / inputs / outputs
+  'input',
+  'model',
+  'output',
+  'outputFromObservable',
+  // Angular view queries
+  'viewChild',
+  'viewChildren',
+  'contentChild',
+  'contentChildren',
+  // Angular DI
+  'inject',
+  // Angular lifecycle
+  'effect',
+  'afterNextRender',
+  'afterRender',
+  // RxJS interop
+  'toSignal',
+  'toObservable',
+]);
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noReadonlySignal = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description: 'Disallow `readonly` on class properties initialized with reactive Angular/RxJS APIs.',
+      recommended: true,
+    },
+    messages: {
+      noReadonlySignal:
+        "Remove `readonly` from '{{name}}' — reactive APIs return mutable references, and `readonly` gives a false sense of immutability.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        // Only flag when readonly is set
+        if (!node.readonly) return;
+
+        const init = node.value;
+        if (!init || init.type !== 'CallExpression') return;
+
+        const { callee } = init;
+        let apiName = null;
+
+        // Simple call: signal(), input(), computed(), inject(), etc.
+        if (callee.type === 'Identifier' && REACTIVE_APIS.has(callee.name)) {
+          apiName = callee.name;
+        }
+        // Member call: input.required(), outputFromObservable.something(), etc.
+        else if (
+          callee.type === 'MemberExpression' &&
+          callee.object.type === 'Identifier' &&
+          REACTIVE_APIS.has(callee.object.name)
+        ) {
+          apiName = `${callee.object.name}.${callee.property.type === 'Identifier' ? callee.property.name : '...'}`;
+        }
+
+        if (apiName) {
+          context.report({
+            node,
+            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');
+              if (!readonlyToken) return null;
+              // Remove "readonly " (including the trailing space)
+              return fixer.removeRange([readonlyToken.range[0], readonlyToken.range[1] + 1]);
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noReadonlySignal;

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

@@ -0,0 +1,88 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows calling .subscribe() inside Angular's effect() or computed() callbacks.
+ *
+ * This creates unmanaged subscriptions and causes memory leaks because neither
+ * effect() nor computed() provides a lifecycle-tied cleanup mechanism for subscriptions.
+ *
+ * BAD:
+ *   effect(() => {
+ *     const page = this.page();
+ *     this.api.fetch(page).subscribe(res => this.data.set(res)); // ❌
+ *   });
+ *
+ * GOOD:
+ *   toObservable(this.page)
+ *     .pipe(
+ *       switchMap(page => this.api.fetch(page)),
+ *       takeUntilDestroyed(),
+ *     )
+ *     .subscribe();
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noRxjsInEffect = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow .subscribe() inside effect() or computed() callbacks.',
+      recommended: true,
+    },
+    messages: {
+      noSubscribeInEffect:
+        'Avoid calling .subscribe() inside {{context}}(). Use toObservable() + switchMap() + takeUntilDestroyed() instead.',
+    },
+    schema: [],
+  },
+  create(context) {
+    /**
+     * Returns the name of the wrapping reactive context ('effect' | 'computed') if
+     * the given node is inside one, or null otherwise.
+     * @param {import('eslint').Rule.Node} node
+     * @returns {string | null}
+     */
+    const getReactiveContext = (node) => {
+      let crossedFunctionBoundary = false;
+      let current = node.parent;
+      while (current) {
+        if (current.type === 'ArrowFunctionExpression' || current.type === 'FunctionExpression') {
+          crossedFunctionBoundary = true;
+        }
+        if (
+          crossedFunctionBoundary &&
+          current.type === 'CallExpression' &&
+          current.callee.type === 'Identifier' &&
+          (current.callee.name === 'effect' || current.callee.name === 'computed')
+        ) {
+          return current.callee.name;
+        }
+        current = current.parent;
+      }
+      return null;
+    };
+
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (
+          callee.type === 'MemberExpression' &&
+          callee.property.type === 'Identifier' &&
+          callee.property.name === 'subscribe'
+        ) {
+          const reactiveContext = getReactiveContext(node);
+          if (reactiveContext) {
+            context.report({
+              node,
+              messageId: 'noSubscribeInEffect',
+              data: { context: reactiveContext },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = noRxjsInEffect;

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

@@ -0,0 +1,113 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows SCREAMING_CASE variable names inside function bodies.
+ *
+ * At module level, SCREAMING_CASE is fine for true constants. Inside functions,
+ * all local variables must be camelCase — there is no meaningful distinction
+ * between a "constant" and a regular local variable inside a function body.
+ *
+ * Also disallows SCREAMING_CASE names for function-valued variables at any scope,
+ * since a function is never a static constant.
+ *
+ * BAD:
+ *   const myFn = () => {
+ *     const RANDOM = Math.random();     // ❌
+ *     const MY_LOCAL_FLAG = true;       // ❌
+ *   };
+ *
+ *   const MY_FUNCTION = () => {};       // ❌ function name must be camelCase
+ *
+ * GOOD:
+ *   const MY_GLOBAL = 'value';          // ✅ module level
+ *
+ *   const myFn = () => {
+ *     const random = Math.random();     // ✅
+ *     const myLocalFlag = true;         // ✅
+ *   };
+ */
+
+/** Matches ALL-CAPS identifiers: at least one char, all uppercase letters, digits, underscores */
+const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
+
+/**
+ * Returns true if the given node is inside a function body (arrow or regular).
+ * @param {import('eslint').Rule.Node} node
+ */
+const isInsideFunction = (node) => {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === 'ArrowFunctionExpression' ||
+      current.type === 'FunctionExpression' ||
+      current.type === 'FunctionDeclaration'
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noScreamingCaseLocal = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow SCREAMING_CASE variable names inside function bodies. Use camelCase for all local variables.',
+      recommended: true,
+    },
+    messages: {
+      noScreamingCaseLocal: "'{{name}}' uses SCREAMING_CASE inside a function. Use camelCase for local variables.",
+      noScreamingCaseFunctionName:
+        "'{{name}}' uses SCREAMING_CASE for a function name. Use camelCase for function names.",
+    },
+    schema: [],
+  },
+  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;
+
+        context.report({
+          node: node.id,
+          messageId: 'noScreamingCaseLocal',
+          data: { name },
+        });
+      },
+
+      // Catch SCREAMING_CASE names for function-valued variables at any scope:
+      // const MY_FUNCTION = () => {}  ❌
+      // const MY_FUNCTION = function() {}  ❌
+      /** @param {import('estree').VariableDeclarator & import('eslint').Rule.NodeParentExtension} node */
+      'VariableDeclarator[init.type="ArrowFunctionExpression"], VariableDeclarator[init.type="FunctionExpression"]'(
+        node,
+      ) {
+        if (node.id.type !== 'Identifier') return;
+
+        const { name } = /** @type {import('estree').Identifier} */ (node.id);
+
+        if (!SCREAMING_CASE_RE.test(name)) return;
+
+        context.report({
+          node: /** @type {import('eslint').Rule.Node} */ (node.id),
+          messageId: 'noScreamingCaseFunctionName',
+          data: { name },
+        });
+      },
+    };
+  },
+};
+
+module.exports = noScreamingCaseLocal;

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;