@ethlete/eslint-plugin 1.0.0-next.12 → 1.0.0-next.14

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 1.0.0-next.14
+
+### Patch Changes
+
+- [`423b30b`](https://github.com/ethlete-io/ethdk/commit/423b30ba4f368d7cee8c464ebd89b5df20d3934c) Thanks [@TomTomB](https://github.com/TomTomB)! - The `static` class member ban now excepts `ngTemplateContextGuard`, which Angular's template type checker requires to be static.
+
+- [`7ca77d4`](https://github.com/ethlete-io/ethdk/commit/7ca77d4a9e1dd3abad7237227c62643159719b74) Thanks [@TomTomB](https://github.com/TomTomB)! - `no-trivial-return-type`: self-referencing (recursive) functions keep their return type annotation — TypeScript cannot infer a return type that depends on itself (TS7023), so the fixer no longer strips it there.
+
+## 1.0.0-next.13
+
+### Minor Changes
+
+- [#3022](https://github.com/ethlete-io/ethdk/pull/3022) [`5a43c83`](https://github.com/ethlete-io/ethdk/commit/5a43c8347a98a815562d1bb0f59bc0db1d765262) Thanks [@github-actions](https://github.com/apps/github-actions)! - Recommended config: the `@Injectable` ban now also flags Angular 22's `@Service` decorator — use `createProvider` / `createRootProvider` from `@ethlete/core` instead.
+
+- [#3022](https://github.com/ethlete-io/ethdk/pull/3022) [`9be3738`](https://github.com/ethlete-io/ethdk/commit/9be3738e18ef1837841c79131127fa42406a3e92) Thanks [@github-actions](https://github.com/apps/github-actions)! - New template rule `ethlete/prefer-static-boolean-properties` (in `recommendedTemplate` as `warn`): flags property bindings of static booleans like `[isReadonly]="true"` and suggests the static-attribute form (`isReadonly` / `isReadonly="false"`). Suggestion-only, since the rewrite is only safe for inputs with a `booleanAttribute` transform.
+
 ## 1.0.0-next.12
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.12",
+  "version": "1.0.0-next.14",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -139,9 +139,10 @@ const recommendedTs = {
         selector: 'FunctionExpression[async=true]',
         message: 'No async/await. Use RxJS for all async operations.',
       },
-      // No static class members
+      // No static class members — except ngTemplateContextGuard, which Angular's template
+      // type checker requires to be static (it types a structural directive's `let-` bindings)
       {
-        selector: 'MethodDefinition[static=true]',
+        selector: "MethodDefinition[static=true]:not([key.name='ngTemplateContextGuard'])",
         message: 'No static class members.',
       },
       {
@@ -169,10 +170,12 @@ const recommendedTs = {
         message:
           'No legacy Angular lifecycle hooks. Use afterNextRender, inject(DestroyRef).onDestroy, or constructor-based effects instead.',
       },
-      // No @Injectable — use createRootProvider / createProvider from @ethlete/core
+      // No @Injectable / @Service — use createRootProvider / createProvider from @ethlete/core
       {
-        selector: "Decorator[expression.callee.name='Injectable'], Decorator[expression.name='Injectable']",
-        message: 'No @Injectable services. Use createRootProvider / createProvider from @ethlete/core instead.',
+        selector:
+          'Decorator[expression.callee.name=/^(Injectable|Service)$/], Decorator[expression.name=/^(Injectable|Service)$/]',
+        message:
+          'No @Injectable / @Service services. Use createRootProvider / createProvider from @ethlete/core instead.',
       },
       // No route guards — handle access control inside the component itself
       {
@@ -403,6 +406,10 @@ const recommendedTemplate = {
     '@angular-eslint/template/no-any': 'error',
     // Prefer plain attribute over unnecessary property binding for static strings: etIcon="foo" not [etIcon]="'foo'"
     '@angular-eslint/template/prefer-static-string-properties': 'error',
+    // Prefer plain attribute over unnecessary property binding for static booleans: isReadonly not [isReadonly]="true"
+    // (warn + suggestion-only: the rewrite is only safe when the input has a booleanAttribute transform,
+    // which a template rule cannot verify)
+    'ethlete/prefer-static-boolean-properties': 'warn',
   },
 };
 

package/src/index.js

@@ -50,6 +50,7 @@ const preferConciseAngularStyleMetadata = require('./rules/prefer-concise-angula
 const noTypedInjectedElementRef = require('./rules/no-typed-injected-element-ref');
 const noNativeHtmlInputName = require('./rules/no-native-html-input-name');
 const preferPresentTenseOutput = require('./rules/prefer-present-tense-output');
+const preferStaticBooleanProperties = require('./rules/prefer-static-boolean-properties');
 const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 
 /** @type {import('eslint').ESLint.Plugin} */
@@ -108,6 +109,7 @@ const plugin = {
     'no-typed-injected-element-ref': noTypedInjectedElementRef,
     'no-native-html-input-name': noNativeHtmlInputName,
     'prefer-present-tense-output': preferPresentTenseOutput,
+    'prefer-static-boolean-properties': preferStaticBooleanProperties,
   },
 };
 
@@ -121,6 +123,7 @@ const recommendedTsWithPlugin = {
 /** @type {import('eslint').Linter.Config} */
 const recommendedTemplateWithPlugin = {
   ...recommendedTemplate,
+  plugins: { ethlete: plugin },
 };
 
 const configs = {

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

@@ -11,6 +11,11 @@
  *
  * ALSO GOOD (non-trivial, keep it):
  *   const parse = (): Date => new Date(value)
+ *
+ * Self-referencing (recursive) functions are exempt: TypeScript cannot infer a
+ * return type that depends on itself (TS7023 under noImplicitAny), so the
+ * annotation is required there:
+ *   const walk = (node): boolean => node.ok && walk(node.next)
  */
 
 const TRIVIAL_TYPES = new Set([
@@ -69,6 +74,93 @@ const noTrivialReturnType = {
       return false;
     };
 
+    /**
+     * The names under which a function implementation can call itself: its own name
+     * (named function expression, or the variable an arrow is assigned to) and/or
+     * `this.<key>` for class/object methods and class-field arrows.
+     * @param {any} fn
+     */
+    const selfReferenceNames = (fn) => {
+      /** @type {{ kind: 'name' | 'this', name: string }[]} */
+      const names = [];
+
+      if (fn.id && fn.id.type === 'Identifier') {
+        names.push({ kind: 'name', name: fn.id.name });
+      }
+
+      const parent = fn.parent;
+
+      if (parent) {
+        if (
+          (parent.type === 'MethodDefinition' || parent.type === 'PropertyDefinition' || parent.type === 'Property') &&
+          !parent.computed &&
+          parent.key &&
+          parent.key.type === 'Identifier'
+        ) {
+          names.push({ kind: 'this', name: parent.key.name });
+        }
+
+        if (parent.type === 'VariableDeclarator' && parent.id && parent.id.type === 'Identifier') {
+          names.push({ kind: 'name', name: parent.id.name });
+        }
+      }
+
+      return names;
+    };
+
+    /**
+     * Whether the function body references the function itself (recursion) — there the
+     * annotation is required, since TypeScript cannot infer a self-dependent return type.
+     * @param {any} fn
+     */
+    const isSelfReferencing = (fn) => {
+      const names = selfReferenceNames(fn);
+
+      if (!names.length || !fn.body) {
+        return false;
+      }
+
+      const stack = [fn.body];
+
+      while (stack.length) {
+        const current = stack.pop();
+
+        if (!current || typeof current !== 'object') continue;
+
+        if (Array.isArray(current)) {
+          stack.push(...current);
+          continue;
+        }
+
+        if (typeof current.type !== 'string') continue;
+
+        for (const { kind, name } of names) {
+          if (kind === 'name' && current.type === 'Identifier' && current.name === name) {
+            return true;
+          }
+
+          if (
+            kind === 'this' &&
+            current.type === 'MemberExpression' &&
+            current.object.type === 'ThisExpression' &&
+            !current.computed &&
+            current.property.type === 'Identifier' &&
+            current.property.name === name
+          ) {
+            return true;
+          }
+        }
+
+        for (const key of Object.keys(current)) {
+          if (key === 'parent') continue;
+          const value = current[key];
+          if (value && typeof value === 'object') stack.push(value);
+        }
+      }
+
+      return false;
+    };
+
     /**
      * @param {import('eslint').Rule.Node} node
      */
@@ -81,6 +173,7 @@ const noTrivialReturnType = {
 
       const annotation = fn.returnType.typeAnnotation;
       if (!TRIVIAL_TYPES.has(annotation.type)) return;
+      if (isSelfReferencing(fn)) return;
 
       const label = TRIVIAL_LABELS[annotation.type] ?? annotation.type;
 

package/src/rules/prefer-static-boolean-properties.js

@@ -0,0 +1,85 @@
+// @ts-check
+'use strict';
+
+/**
+ * Flags property bindings whose value is a static boolean literal:
+ *
+ *   <my-cmp [isReadonly]="true" />
+ *   <my-cmp [isReadonly]="false" />
+ *
+ * If the target input uses a `booleanAttribute` transform (the styleguide
+ * default for boolean inputs), the binding is unnecessary — a static attribute
+ * expresses the same thing without a change-detection expression:
+ *
+ *   <my-cmp isReadonly />          (true)
+ *   <my-cmp isReadonly="false" />  (false — `booleanAttribute` coerces the string 'false' to false)
+ *
+ * Whether the input actually has that transform is invisible to a template
+ * rule (no type information), so the rewrite is offered as a suggestion, not
+ * an auto-fix: without the transform a static attribute would pass the string
+ * 'true' / 'false' instead of a boolean.
+ *
+ * Companion to `@angular-eslint/template/prefer-static-string-properties`,
+ * which covers the string-literal case (where the rewrite is always safe).
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const preferStaticBooleanProperties = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer a static attribute over a property binding for static boolean values when the input uses a booleanAttribute transform.',
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      preferStaticBooleanProperty:
+        'Binding a static boolean is unnecessary if the `{{ name }}` input uses a `booleanAttribute` transform — use a static attribute instead. Keep the binding if the input takes a plain boolean without a transform.',
+      useBareAttribute: 'Replace with the bare attribute `{{ name }}`',
+      useStaticAttribute: 'Replace with the static attribute `{{ name }}="false"`',
+    },
+  },
+  create(context) {
+    const parserServices = /** @type {any} */ (context.sourceCode.parserServices);
+
+    // Only meaningful when parsed with @angular-eslint/template-parser
+    if (!parserServices?.convertNodeSourceSpanToLoc) return {};
+
+    return {
+      /** @param {any} node */
+      ['BoundAttribute.inputs'](node) {
+        const { name, sourceSpan, keySpan, value } = node;
+
+        // Exclude @animation, class./style./attr. sub-properties, and
+        // structural directives (*foo has no keySpan details)
+        const isBindingProperty = keySpan?.details && !keySpan.details.includes('@') && !keySpan.details.includes('.');
+        if (!isBindingProperty) return;
+
+        // Only literal `true` / `false` expressions. `value.ast` is a
+        // LiteralPrimitive for literals; the raw-source check guards against
+        // other node shapes that happen to carry a boolean `value`.
+        const source = typeof value?.source === 'string' ? value.source.trim() : null;
+        if (typeof value?.ast?.value !== 'boolean' || (source !== 'true' && source !== 'false')) return;
+
+        const isTrue = value.ast.value === true;
+        const replacement = isTrue ? name : `${name}="false"`;
+
+        context.report({
+          loc: parserServices.convertNodeSourceSpanToLoc(sourceSpan),
+          messageId: 'preferStaticBooleanProperty',
+          data: { name },
+          suggest: [
+            {
+              messageId: isTrue ? 'useBareAttribute' : 'useStaticAttribute',
+              data: { name },
+              fix: (fixer) => fixer.replaceTextRange([sourceSpan.start.offset, sourceSpan.end.offset], replacement),
+            },
+          ],
+        });
+      },
+    };
+  },
+};
+
+module.exports = preferStaticBooleanProperties;