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

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

@@ -0,0 +1,151 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows class members that exist solely as aliases for a nested property or
+ * zero-arg method of another class member accessed via `this`.
+ *
+ * These aliases add an extra layer of indirection without any benefit. Instead,
+ * the source member should be widened in accessibility so it can be referenced
+ * directly at the call/template site.
+ *
+ * BAD — property alias:
+ *   private stackDirective = inject(NotificationStackDirective);
+ *   protected displayRefs = this.stackDirective.displayRefs;   // just an alias
+ *
+ * BAD — zero-arg method alias:
+ *   context = inject(SomeContextToken);
+ *   retry() { this.context.retry(); }
+ *
+ * GOOD:
+ *   protected stackDirective = inject(NotificationStackDirective);
+ *   // use stackDirective.displayRefs directly in the template
+ *
+ *   context = inject(SomeContextToken);
+ *   // callers use directive.context.retry() directly
+ *
+ * Property rule fires when the entire initializer is a single `this.a.b`
+ * expression — it will not flag deeper chains, computed accesses, or any
+ * expression that does more than a plain property read.
+ *
+ * Method rule fires when a zero-param method body contains exactly one
+ * statement that calls `this.a.b()` with zero arguments AND the method name
+ * matches the target method name exactly. When the names differ the method is
+ * an intentional API rename (e.g. retry → playerResource.reload) and is not
+ * flagged.
+ */
+
+/**
+ * Checks whether a method node is a pure zero-arg forwarding alias of the form:
+ *   method() { this.source.method(); }
+ *   method() { return this.source.method(); }
+ *
+ * @param {any} node  MethodDefinition
+ * @returns {{ sourceName: string, propName: string } | null}
+ */
+const getMethodAliasInfo = (node) => {
+  if (node.kind === 'constructor' || node.kind === 'get' || node.kind === 'set') return null;
+
+  const fn = node.value;
+  if (!fn || fn.params.length !== 0) return null;
+
+  const body = fn.body;
+  if (!body || body.type !== 'BlockStatement' || 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;
+
+  // 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;
+
+  const obj = callee.object;
+  if (obj.type !== 'MemberExpression') return null;
+  if (obj.computed) return null;
+  if (obj.object.type !== 'ThisExpression') return null;
+  if (obj.property.type !== 'Identifier') return null;
+
+  return { sourceName: obj.property.name, propName: callee.property.name };
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noMemberAlias = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow class members that are pure aliases for a nested property or zero-arg method of another member accessed via `this`.',
+      recommended: true,
+    },
+    messages: {
+      noAlias:
+        '`{{alias}}` is a pure alias for `this.{{source}}.{{prop}}`. ' +
+        'Remove the alias and widen the accessibility of `{{source}}` so it can be used directly.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        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;
+        if (obj.property.type !== 'Identifier') return;
+
+        const aliasName = node.key.type === 'Identifier' ? node.key.name : null;
+        if (!aliasName) return;
+
+        const sourceName = obj.property.name;
+        const propName = value.property.name;
+
+        context.report({
+          node,
+          messageId: 'noAlias',
+          data: { alias: aliasName, source: sourceName, prop: propName },
+        });
+      },
+
+      MethodDefinition(node) {
+        const aliasName = node.key.type === 'Identifier' ? node.key.name : null;
+        if (!aliasName) return;
+
+        const info = getMethodAliasInfo(node);
+        if (!info) return;
+
+        // Only flag when names match — different names indicate an intentional
+        // API rename, which is not a pure alias.
+        if (aliasName !== info.propName) return;
+
+        context.report({
+          node,
+          messageId: 'noAlias',
+          data: { alias: aliasName, source: info.sourceName, prop: info.propName },
+        });
+      },
+    };
+  },
+};
+
+module.exports = noMemberAlias;

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

@@ -0,0 +1,102 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallows raw browser Observer APIs (IntersectionObserver, MutationObserver,
+ * ResizeObserver, PerformanceObserver). Use the signal-based utilities from
+ * @ethlete/core instead.
+ *
+ * The signal utilities:
+ * - Integrate automatically with Angular's reactivity model
+ * - Tear down the observer when the component is destroyed (no memory leaks)
+ * - Are composable with other signals and computed()
+ * - Require no manual disconnect() calls
+ *
+ * BAD:
+ *   new IntersectionObserver(cb, options)
+ *   new MutationObserver(cb)
+ *   new ResizeObserver(cb)
+ *
+ * GOOD:
+ *   // IntersectionObserver → from @ethlete/core
+ *   signalElementIntersection(elementRef, options)
+ *   signalHostElementIntersection(options)   // shortcut inside a directive/component
+ *
+ *   // MutationObserver → from @ethlete/core
+ *   signalElementMutations(elementRef, options)
+ *   signalHostElementMutations(options)
+ *
+ *   // ResizeObserver → from @ethlete/core
+ *   signalElementDimensions(elementRef)
+ *   signalHostElementDimensions()
+ */
+
+/**
+ * Maps Observer constructor names to their @ethlete/core signal equivalents.
+ * @type {Record<string, { alternatives: string[], from: string } | null>}
+ */
+const OBSERVER_ALTERNATIVES = {
+  IntersectionObserver: {
+    alternatives: ['signalElementIntersection', 'signalHostElementIntersection'],
+    from: '@ethlete/core',
+  },
+  MutationObserver: {
+    alternatives: ['signalElementMutations', 'signalHostElementMutations'],
+    from: '@ethlete/core',
+  },
+  ResizeObserver: {
+    alternatives: ['signalElementDimensions', 'signalHostElementDimensions'],
+    from: '@ethlete/core',
+  },
+  PerformanceObserver: null,
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noNativeObservers = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: "Disallow raw browser Observer APIs. Use signal-based utilities from '@ethlete/core' instead.",
+      recommended: true,
+    },
+    messages: {
+      useSignalUtil:
+        "Use '{{alternatives}}' from '{{from}}' instead of 'new {{observer}}()'. The signal utility auto-cleans up when the component is destroyed.",
+      avoidObserver:
+        "Avoid 'new {{observer}}()'. Prefer a reactive signal utility from '@ethlete/core' where possible, or ensure you call disconnect() in inject(DestroyRef).onDestroy().",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (node.callee.type !== 'Identifier') return;
+
+        const name = node.callee.name;
+        if (!(name in OBSERVER_ALTERNATIVES)) 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 },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noNativeObservers;

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

@@ -0,0 +1,76 @@
+// @ts-check
+'use strict';
+
+/**
+ * Checks whether a class node has a @Pipe decorator.
+ * @param {import('eslint').Rule.Node} classNode
+ */
+const hasPipeDecorator = (classNode) => {
+  const decorators = /** @type {any} */ (classNode).decorators ?? [];
+  return decorators.some((/** @type {any} */ dec) => {
+    const expr = dec.expression;
+    if (expr.type === 'CallExpression') {
+      return expr.callee.type === 'Identifier' && expr.callee.name === 'Pipe';
+    }
+    if (expr.type === 'Identifier') {
+      return expr.name === 'Pipe';
+    }
+    return false;
+  });
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noPipeLogic = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Pipes must not contain logic in the transform method. Extract to a utility function and assign it: `transform = myUtil;`',
+    },
+    messages: {
+      noLogicInTransform:
+        'Pipes must not contain logic in transform. Extract to a utility function and assign it: `transform = myUtil;`',
+    },
+    schema: [],
+  },
+  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;
+
+        const classBody = node.parent;
+        if (!classBody || classBody.type !== 'ClassBody') return;
+
+        const classNode = classBody.parent;
+        if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
+
+        if (!hasPipeDecorator(classNode)) return;
+
+        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;
+
+        const classBody = node.parent;
+        if (!classBody || classBody.type !== 'ClassBody') return;
+
+        const classNode = classBody.parent;
+        if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
+
+        if (!hasPipeDecorator(classNode)) return;
+
+        const value = /** @type {any} */ (node).value;
+        if (value && (value.type === 'ArrowFunctionExpression' || value.type === 'FunctionExpression')) {
+          context.report({ node, messageId: 'noLogicInTransform' });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noPipeLogic;

package/src/rules/no-public-property.js

@@ -0,0 +1,50 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {any} node
+ */
+const isInjectCall = (node) => {
+  if (!node || node.type !== 'CallExpression') return false;
+  return node.callee.type === 'Identifier' && node.callee.name === 'inject';
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noPublicProperty = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow explicit public on class properties, except for injected members that intentionally expose an external API.',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noPublicProperty:
+        'No public keyword on class properties. The only exception is an injected member that intentionally exposes an external API.',
+    },
+  },
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        if (node.accessibility !== 'public') return;
+        if (isInjectCall(node.value)) return;
+
+        context.report({
+          node,
+          messageId: 'noPublicProperty',
+          fix(fixer) {
+            const publicToken = context.sourceCode.getFirstToken(node, (token) => token.value === 'public');
+            const nextToken = publicToken ? context.sourceCode.getTokenAfter(publicToken) : null;
+            if (!publicToken || !nextToken) return null;
+
+            return fixer.removeRange([publicToken.range[0], nextToken.range[0]]);
+          },
+        });
+      },
+    };
+  },
+};
+
+module.exports = noPublicProperty;

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;