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

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.0-next.3
+
+### Patch Changes
+
+- [`5d1d3ac`](https://github.com/ethlete-io/ethdk/commit/5d1d3accbd4a7657bc50cdc0653a7ca24fe761e2) Thanks [@TomTomB](https://github.com/TomTomB)! - Fix minor lint edge cases
+
+## 0.1.0-next.2
+
+### Patch Changes
+
+- [#2957](https://github.com/ethlete-io/ethdk/pull/2957) [`81173d4`](https://github.com/ethlete-io/ethdk/commit/81173d426d1a53ea2a7af0d16d6eb0fe4a16dbd9) Thanks [@github-actions](https://github.com/apps/github-actions)! - Add missing auto fixers
+
 ## 0.1.0-next.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "0.1.0-next.1",
+  "version": "0.1.0-next.3",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -8,6 +8,7 @@
     "@angular-eslint/eslint-plugin-template": ">=21.0.0",
     "@typescript-eslint/eslint-plugin": ">=8.0.0",
     "eslint": ">=9.0.0",
-    "tslib": "2.8.1"
+    "tslib": "2.8.1",
+    "typescript": "5.9.3"
   }
 }

package/src/configs/recommended.js

@@ -71,10 +71,16 @@ const recommendedTs = {
       },
       {
         selector: ['variable', 'parameter', 'property', 'parameterProperty', 'accessor'],
-        leadingUnderscore: 'forbid',
+        leadingUnderscore: 'allow',
         trailingUnderscore: 'forbid',
         format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
       },
+      {
+        selector: 'method',
+        leadingUnderscore: 'allow',
+        trailingUnderscore: 'forbid',
+        format: null,
+      },
       {
         selector: 'typeLike',
         leadingUnderscore: 'forbid',
@@ -133,11 +139,6 @@ const recommendedTs = {
         selector: 'FunctionExpression[async=true]',
         message: 'No async/await. Use RxJS for all async operations.',
       },
-      // No public keyword on class members
-      {
-        selector: "MethodDefinition[accessibility='public']",
-        message: 'No public keyword on class members.',
-      },
       // No static class members
       {
         selector: 'MethodDefinition[static=true]',
@@ -212,8 +213,18 @@ const recommendedTs = {
     // No inject(X).member chaining — assign to a const first
     'ethlete/no-inject-chain': 'error',
 
-    // No public properties except explicit injected external APIs
-    'ethlete/no-public-property': 'error',
+    // inject(ElementRef) must use inject<ElementRef<HTMLElement>>(ElementRef) — not inject(ElementRef) or inject(ElementRef<...>)
+    'ethlete/no-typed-injected-element-ref': 'error',
+
+    // No @internal on members already hidden by private/protected
+    'ethlete/no-redundant-internal': 'error',
+
+    // Non-injected Angular members should use explicit accessibility when they
+    // participate in the reachable surface. Template/host members must be
+    // explicit, other implicit-public members must be public. @internal does
+    // not replace explicit public; protected remains valid for template-only
+    // members.
+    'ethlete/template-member-accessibility': 'error',
 
     // No explicit trivial return types TypeScript can infer
     'ethlete/no-trivial-return-type': 'error',
@@ -269,6 +280,9 @@ const recommendedTs = {
     // No `import type { Foo }` or `import { type Foo }` — use regular value imports
     'ethlete/no-type-only-import': 'error',
 
+    // No empty blank lines between import declarations
+    'ethlete/no-empty-newlines-between-imports': 'error',
+
     // No legacy Angular decorators — use signal-based APIs (input, output, viewChild, etc.)
     // and host: {} bindings (instead of @HostBinding / @HostListener)
     'ethlete/no-legacy-angular-decorators': 'error',
@@ -304,6 +318,9 @@ const recommendedTs = {
     // — widen the accessibility of the source member instead
     'ethlete/no-member-alias': 'error',
 
+    // No leading underscores on class members; auto-fix private members when safe
+    'ethlete/no-leading-underscore-class-member': 'error',
+
     // No declared-but-never-read private/protected class members
     'ethlete/no-unused-class-member': 'error',
 
@@ -311,6 +328,12 @@ const recommendedTs = {
     // — use viewChild() / viewChildren() or contentChild() / contentChildren() instead
     'ethlete/no-dom-query': 'error',
 
+    // Remove empty imports: [] and hostDirectives: [] metadata noise
+    'ethlete/no-empty-angular-metadata-arrays': 'error',
+
+    // Remove standalone metadata — standalone is implicit and should not be declared
+    'ethlete/no-standalone-flag': 'error',
+
     // ── Angular outputs ─────────────────────────────────────────────────────
 
     // No on-prefixed outputs (onSelectDate → selectDate)
@@ -322,7 +345,7 @@ const recommendedTs = {
     // ── Angular components ──────────────────────────────────────────────────
 
     // Always use ChangeDetectionStrategy.OnPush
-    '@angular-eslint/prefer-on-push-component-change-detection': 'error',
+    'ethlete/require-on-push-change-detection': 'error',
 
     // Always use ViewEncapsulation.None (angular-eslint's use-component-view-encapsulation does the
     // opposite — it disallows None, so we use our own custom rule instead)
@@ -331,6 +354,12 @@ const recommendedTs = {
     // Keep Angular @Component / @Directive metadata in a consistent order
     'ethlete/angular-decorator-property-order': 'error',
 
+    // Keep class members in the documented styleguide order
+    'ethlete/class-member-order': 'error',
+
+    // True class constants should be readonly and use SCREAMING_CASE
+    'ethlete/class-constant-property': 'error',
+
     // Prefer shorthand hostDirectives entries and keep extended host directive configs ordered
     'ethlete/prefer-concise-angular-host-directives': 'error',
 
@@ -359,4 +388,16 @@ const recommendedTemplate = {
   },
 };
 
-module.exports = { recommendedTs, recommendedTemplate };
+/**
+ * Relaxed rules for test/spec files.
+ * Non-null assertions are common and intentional in tests.
+ * @type {import('eslint').Linter.Config}
+ */
+const recommendedSpec = {
+  files: ['**/*.spec.ts'],
+  rules: {
+    '@typescript-eslint/no-non-null-assertion': 'off',
+  },
+};
+
+module.exports = { recommendedTs, recommendedTemplate, recommendedSpec };

package/src/index.js

@@ -22,6 +22,7 @@ const noSubscribeWithBody = require('./rules/no-subscribe-with-body');
 const requireDollarSuffix = require('./rules/require-dollar-suffix');
 const noPipeLogic = require('./rules/no-pipe-logic');
 const enforceRoutingViewNaming = require('./rules/enforce-routing-view-naming');
+const requireOnPushChangeDetection = require('./rules/require-on-push-change-detection');
 const requireViewEncapsulationNone = require('./rules/require-view-encapsulation-none');
 const noLegacyAngularDecorators = require('./rules/no-legacy-angular-decorators');
 const noAngularSeoServices = require('./rules/no-angular-seo-services');
@@ -29,16 +30,25 @@ const preferCloneEqual = require('./rules/prefer-clone-equal');
 const noDocumentCookie = require('./rules/no-document-cookie');
 const injectMemberAccessibility = require('./rules/inject-member-accessibility');
 const noPublicProperty = require('./rules/no-public-property');
+const noRedundantInternal = require('./rules/no-redundant-internal');
+const templateMemberAccessibility = require('./rules/template-member-accessibility');
 const noAngularRouterApi = require('./rules/no-angular-router-api');
 const noWindowLocation = require('./rules/no-window-location');
 const noLocaleId = require('./rules/no-locale-id');
 const noMemberAlias = require('./rules/no-member-alias');
 const noUnusedClassMember = require('./rules/no-unused-class-member');
 const noDomQuery = require('./rules/no-dom-query');
+const noLeadingUnderscoreClassMember = require('./rules/no-leading-underscore-class-member');
+const noEmptyAngularMetadataArrays = require('./rules/no-empty-angular-metadata-arrays');
+const noStandaloneFlag = require('./rules/no-standalone-flag');
+const noEmptyNewlinesBetweenImports = require('./rules/no-empty-newlines-between-imports');
 const angularDecoratorPropertyOrder = require('./rules/angular-decorator-property-order');
+const classMemberOrder = require('./rules/class-member-order');
+const classConstantProperty = require('./rules/class-constant-property');
 const preferConciseAngularHostDirectives = require('./rules/prefer-concise-angular-host-directives');
 const preferConciseAngularStyleMetadata = require('./rules/prefer-concise-angular-style-metadata');
-const { recommendedTs, recommendedTemplate } = require('./configs/recommended');
+const noTypedInjectedElementRef = require('./rules/no-typed-injected-element-ref');
+const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 
 /** @type {import('eslint').ESLint.Plugin} */
 const plugin = {
@@ -68,6 +78,7 @@ const plugin = {
     'require-dollar-suffix': requireDollarSuffix,
     'no-pipe-logic': noPipeLogic,
     'enforce-routing-view-naming': enforceRoutingViewNaming,
+    'require-on-push-change-detection': requireOnPushChangeDetection,
     'require-view-encapsulation-none': requireViewEncapsulationNone,
     'no-legacy-angular-decorators': noLegacyAngularDecorators,
     'no-angular-seo-services': noAngularSeoServices,
@@ -75,15 +86,24 @@ const plugin = {
     'no-document-cookie': noDocumentCookie,
     'inject-member-accessibility': injectMemberAccessibility,
     'no-public-property': noPublicProperty,
+    'no-redundant-internal': noRedundantInternal,
+    'template-member-accessibility': templateMemberAccessibility,
     'no-angular-router-api': noAngularRouterApi,
     'no-window-location': noWindowLocation,
     'no-locale-id': noLocaleId,
     'no-member-alias': noMemberAlias,
     'no-unused-class-member': noUnusedClassMember,
     'no-dom-query': noDomQuery,
+    'no-leading-underscore-class-member': noLeadingUnderscoreClassMember,
+    'no-empty-angular-metadata-arrays': noEmptyAngularMetadataArrays,
+    'no-standalone-flag': noStandaloneFlag,
+    'no-empty-newlines-between-imports': noEmptyNewlinesBetweenImports,
     'angular-decorator-property-order': angularDecoratorPropertyOrder,
+    'class-member-order': classMemberOrder,
+    'class-constant-property': classConstantProperty,
     'prefer-concise-angular-host-directives': preferConciseAngularHostDirectives,
     'prefer-concise-angular-style-metadata': preferConciseAngularStyleMetadata,
+    'no-typed-injected-element-ref': noTypedInjectedElementRef,
   },
 };
 
@@ -108,7 +128,7 @@ const configs = {
    * Both together as a flat array — the most common usage:
    *   export default [...baseConfig, ...ethlete.configs.recommended]
    */
-  recommended: [recommendedTsWithPlugin, recommendedTemplateWithPlugin],
+  recommended: [recommendedTsWithPlugin, recommendedTemplateWithPlugin, recommendedSpec],
 };
 
 const ethletePlugin = { ...plugin, configs };

package/src/rules/angular-decorator-property-order.js

@@ -29,28 +29,16 @@ const DECORATOR_CONFIG = {
       'outputs',
       'queries',
       'preserveWhitespaces',
-      'standalone',
       'schemas',
       'jit',
       'exportAs',
     ],
     orderText:
-      'selector, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, standalone, schemas, jit, exportAs',
+      'selector, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, schemas, jit, exportAs',
   },
   Directive: {
-    order: [
-      'selector',
-      'exportAs',
-      'providers',
-      'inputs',
-      'outputs',
-      'queries',
-      'hostDirectives',
-      'host',
-      'standalone',
-      'jit',
-    ],
-    orderText: 'selector, exportAs, providers, inputs, outputs, queries, hostDirectives, host, standalone, jit',
+    order: ['selector', 'exportAs', 'providers', 'inputs', 'outputs', 'queries', 'hostDirectives', 'host', 'jit'],
+    orderText: 'selector, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
   },
 };
 

package/src/rules/class-constant-property.js

@@ -0,0 +1,344 @@
+// @ts-check
+'use strict';
+
+const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
+
+const REACTIVE_APIS = new Set([
+  'signal',
+  'computed',
+  'linkedSignal',
+  'input',
+  'model',
+  'output',
+  'outputFromObservable',
+  'viewChild',
+  'viewChildren',
+  'contentChild',
+  'contentChildren',
+  'inject',
+  'effect',
+  'afterNextRender',
+  'afterRender',
+  'toSignal',
+  'toObservable',
+]);
+
+/**
+ * @param {any} node
+ */
+const getMemberName = (node) => {
+  if (!node || !node.key) return null;
+
+  if (node.key.type === 'Identifier' || node.key.type === 'PrivateIdentifier') {
+    return node.key.name;
+  }
+
+  if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
+    return node.key.value;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ */
+const getCallRootName = (node) => {
+  if (!node || node.type !== 'CallExpression') return null;
+
+  const { callee } = node;
+
+  if (callee.type === 'Identifier') {
+    return callee.name;
+  }
+
+  if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier') {
+    return callee.object.name;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ */
+const isReactiveInitializer = (node) => {
+  const apiName = getCallRootName(node);
+  return apiName !== null && REACTIVE_APIS.has(apiName);
+};
+
+/**
+ * @param {any} node
+ */
+const isThisReference = (node) => node && (node.type === 'ThisExpression' || node.type === 'Super');
+
+/**
+ * @param {any} node
+ */
+const isConstantExpression = (node) => {
+  if (!node) return false;
+
+  switch (node.type) {
+    case 'Literal':
+    case 'Identifier':
+      return true;
+    case 'TemplateLiteral':
+      return node.expressions.every((expression) => isConstantExpression(expression));
+    case 'UnaryExpression':
+    case 'UpdateExpression':
+      return isConstantExpression(node.argument);
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return isConstantExpression(node.left) && isConstantExpression(node.right);
+    case 'ConditionalExpression':
+      return (
+        isConstantExpression(node.test) && isConstantExpression(node.consequent) && isConstantExpression(node.alternate)
+      );
+    case 'ArrayExpression':
+      return node.elements.every((element) => {
+        if (element === null) return true;
+
+        if (element.type === 'SpreadElement') {
+          return isConstantExpression(element.argument);
+        }
+
+        return isConstantExpression(element);
+      });
+    case 'ObjectExpression':
+      return node.properties.every((property) => {
+        if (property.type === 'SpreadElement') {
+          return isConstantExpression(property.argument);
+        }
+
+        if (property.type !== 'Property' || property.kind !== 'init') {
+          return false;
+        }
+
+        if (property.computed && !isConstantExpression(property.key)) {
+          return false;
+        }
+
+        return isConstantExpression(property.value);
+      });
+    case 'MemberExpression':
+      if (isThisReference(node.object)) {
+        return false;
+      }
+
+      if (!isConstantExpression(node.object)) {
+        return false;
+      }
+
+      return node.computed ? isConstantExpression(node.property) : true;
+    case 'TSAsExpression':
+    case 'TSTypeAssertion':
+    case 'TSNonNullExpression':
+    case 'ChainExpression':
+      return isConstantExpression(node.expression);
+    case 'ParenthesizedExpression':
+      return isConstantExpression(node.expression);
+    case 'SequenceExpression':
+      return node.expressions.every((expression) => isConstantExpression(expression));
+    default:
+      return false;
+  }
+};
+
+/**
+ * @param {any} node
+ */
+const getWrittenMemberName = (node) => {
+  if (!node || node.type !== 'MemberExpression' || !isThisReference(node.object)) {
+    return null;
+  }
+
+  if (!node.computed && (node.property.type === 'Identifier' || node.property.type === 'PrivateIdentifier')) {
+    return node.property.name;
+  }
+
+  if (node.computed && node.property.type === 'Literal' && typeof node.property.value === 'string') {
+    return node.property.value;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} target
+ * @param {Set<string>} writtenMembers
+ */
+const collectAssignedMemberNames = (target, writtenMembers) => {
+  if (!target) return;
+
+  if (target.type === 'MemberExpression') {
+    const memberName = getWrittenMemberName(target);
+
+    if (memberName !== null) {
+      writtenMembers.add(memberName);
+    }
+
+    return;
+  }
+
+  if (target.type === 'ArrayPattern') {
+    for (const element of target.elements) {
+      collectAssignedMemberNames(element, writtenMembers);
+    }
+
+    return;
+  }
+
+  if (target.type === 'ObjectPattern') {
+    for (const property of target.properties) {
+      if (property.type === 'Property') {
+        collectAssignedMemberNames(property.value, writtenMembers);
+      } else if (property.type === 'RestElement') {
+        collectAssignedMemberNames(property.argument, writtenMembers);
+      }
+    }
+
+    return;
+  }
+
+  if (target.type === 'AssignmentPattern') {
+    collectAssignedMemberNames(target.left, writtenMembers);
+
+    return;
+  }
+
+  if (target.type === 'RestElement') {
+    collectAssignedMemberNames(target.argument, writtenMembers);
+  }
+};
+
+/**
+ * @param {any} node
+ * @param {Set<string>} writtenMembers
+ */
+const collectWrittenMembers = (node, writtenMembers) => {
+  if (!node || typeof node !== 'object') return;
+
+  if (Array.isArray(node)) {
+    for (const entry of node) {
+      collectWrittenMembers(entry, writtenMembers);
+    }
+
+    return;
+  }
+
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+    return;
+  }
+
+  if (node.type === 'AssignmentExpression') {
+    collectAssignedMemberNames(node.left, writtenMembers);
+  }
+
+  if (node.type === 'UpdateExpression') {
+    const memberName = getWrittenMemberName(node.argument);
+
+    if (memberName !== null) {
+      writtenMembers.add(memberName);
+    }
+  }
+
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'parent' || key === 'range' || key === 'loc') continue;
+    if (!value || typeof value !== 'object') continue;
+
+    collectWrittenMembers(value, writtenMembers);
+  }
+};
+
+/**
+ * @param {any} classBodyNode
+ */
+const getWrittenMembers = (classBodyNode) => {
+  const writtenMembers = new Set();
+
+  for (const member of classBodyNode.body) {
+    collectWrittenMembers(member, writtenMembers);
+  }
+
+  return writtenMembers;
+};
+
+/**
+ * @param {any} node
+ */
+const isConstantProperty = (node) => {
+  if (node.type !== 'PropertyDefinition' || node.static || node.computed || !node.value) {
+    return false;
+  }
+
+  if (isReactiveInitializer(node.value)) {
+    return false;
+  }
+
+  return isConstantExpression(node.value);
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const classConstantProperty = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description: 'Require true class constants to use readonly and SCREAMING_CASE.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      shouldBeReadonly: "'{{name}}' is a class constant and should be declared readonly.",
+      shouldUseScreamingCase: "Readonly class constant '{{name}}' should use SCREAMING_CASE.",
+    },
+  },
+  create(context) {
+    return {
+      ClassBody(node) {
+        const writtenMembers = getWrittenMembers(node);
+
+        for (const member of node.body) {
+          if (!isConstantProperty(member)) {
+            continue;
+          }
+
+          const memberName = getMemberName(member);
+
+          if (memberName === null || writtenMembers.has(memberName)) {
+            continue;
+          }
+
+          if (!member.readonly) {
+            context.report({
+              node: member,
+              messageId: 'shouldBeReadonly',
+              data: { name: memberName },
+              fix(fixer) {
+                const keyToken = context.sourceCode.getFirstToken(member.key);
+
+                if (!keyToken) {
+                  return null;
+                }
+
+                return fixer.insertTextBefore(keyToken, 'readonly ');
+              },
+            });
+
+            continue;
+          }
+
+          if (!SCREAMING_CASE_RE.test(memberName)) {
+            context.report({
+              node: member.key,
+              messageId: 'shouldUseScreamingCase',
+              data: { name: memberName },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = classConstantProperty;