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

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "0.1.0-next.2",
+  "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

@@ -139,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]',
@@ -218,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',
@@ -349,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',
 
@@ -377,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

@@ -30,6 +30,8 @@ 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');
@@ -41,9 +43,12 @@ const noEmptyAngularMetadataArrays = require('./rules/no-empty-angular-metadata-
 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 = {
@@ -81,6 +86,8 @@ 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,
@@ -92,8 +99,11 @@ const plugin = {
     '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,
   },
 };
 
@@ -118,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/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;