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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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.13",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -169,10 +169,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 +405,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/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;