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

package/src/rules/no-leading-underscore-class-member.js

@@ -0,0 +1,120 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {string} name
+ */
+const getFixedName = (name) => name.replace(/^_+/, '');
+
+/**
+ * @param {any} node
+ */
+const getDirectMemberName = (node) => {
+  if (node.parent?.type !== 'ClassBody') return null;
+  if (node.static || node.computed) return null;
+  if (node.type === 'MethodDefinition' && node.kind === 'constructor') return null;
+  return node.key?.type === 'Identifier' ? node.key.name : null;
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noLeadingUnderscoreClassMember = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow leading underscores on class members and rename private members automatically when safe.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noLeadingUnderscore: "Class members must not use a leading underscore. Rename '{{oldName}}' to '{{newName}}'.",
+    },
+  },
+  create(context) {
+    /**
+     * @type {Array<{
+     *   classBody: import('eslint').Rule.Node,
+     *   declaredNames: Set<string>,
+     *   membersByName: Map<string, any[]>,
+     *   memberReads: any[],
+     * }>}
+     */
+    const classStack = [];
+
+    /**
+     * @param {any} node
+     */
+    const registerMember = (node) => {
+      const frame = classStack[classStack.length - 1];
+      if (!frame || node.parent !== frame.classBody) return;
+
+      const name = getDirectMemberName(node);
+      if (!name) return;
+
+      frame.declaredNames.add(name);
+
+      if (!name.startsWith('_')) return;
+
+      const members = frame.membersByName.get(name) ?? [];
+      members.push(node);
+      frame.membersByName.set(name, members);
+    };
+
+    return {
+      ClassBody(node) {
+        classStack.push({
+          classBody: node,
+          declaredNames: new Set(),
+          membersByName: new Map(),
+          memberReads: [],
+        });
+      },
+
+      'ClassBody:exit'() {
+        const frame = classStack.pop();
+        if (!frame) return;
+
+        for (const [oldName, memberNodes] of frame.membersByName) {
+          const newName = getFixedName(oldName);
+          const canFix =
+            newName.length > 0 &&
+            !frame.declaredNames.has(newName) &&
+            memberNodes.every((memberNode) => memberNode.accessibility === 'private');
+
+          for (const memberNode of memberNodes) {
+            context.report({
+              node: memberNode.key,
+              messageId: 'noLeadingUnderscore',
+              data: { oldName, newName },
+              fix: canFix
+                ? (fixer) => {
+                    const fixes = memberNodes.map((node) => fixer.replaceText(node.key, newName));
+
+                    for (const memberExpression of frame.memberReads) {
+                      if (memberExpression.property.name !== oldName) continue;
+                      fixes.push(fixer.replaceText(memberExpression.property, newName));
+                    }
+
+                    return fixes;
+                  }
+                : null,
+            });
+          }
+        }
+      },
+
+      PropertyDefinition: registerMember,
+      MethodDefinition: registerMember,
+
+      MemberExpression(node) {
+        const frame = classStack[classStack.length - 1];
+        if (!frame) return;
+        if (node.object?.type !== 'ThisExpression' || node.computed) return;
+        if (node.property?.type !== 'Identifier') return;
+
+        frame.memberReads.push(node);
+      },
+    };
+  },
+};
+
+module.exports = noLeadingUnderscoreClassMember;

package/src/rules/no-legacy-angular-decorators.js

@@ -51,6 +51,180 @@ const getMemberName = (node) => {
   return null;
 };
 
+/**
+ * @param {import('estree').Property['key']} key
+ * @returns {string | null}
+ */
+const getPropertyName = (key) => {
+  if (key.type === 'Identifier') return key.name;
+  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('eslint').AST.Token | import('eslint').Rule.Node} node
+ */
+const getIndent = (sourceCode, node) => {
+  if (!node.loc) return '';
+  const line = sourceCode.lines[node.loc.start.line - 1] ?? '';
+  return line.slice(0, node.loc.start.column);
+};
+
+/**
+ * @param {any} classNode
+ */
+const getAngularMetadata = (classNode) => {
+  for (const decorator of classNode.decorators ?? []) {
+    const decoratorName = getDecoratorName(decorator);
+    if (decoratorName !== 'Component' && decoratorName !== 'Directive') continue;
+
+    const expression = decorator.expression;
+    if (expression.type !== 'CallExpression') continue;
+
+    const metadata = expression.arguments[0];
+    if (metadata?.type !== 'ObjectExpression') continue;
+
+    return metadata;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} objectExpression
+ * @param {string} propertyName
+ */
+const findObjectProperty = (objectExpression, propertyName) =>
+  objectExpression.properties.find(
+    (property) => property.type === 'Property' && getPropertyName(property.key) === propertyName,
+  ) ?? null;
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} objectExpression
+ * @param {string} entryText
+ */
+const buildObjectTextWithAppendedProperty = (sourceCode, objectExpression, entryText) => {
+  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
+  const isMultiline = Boolean(
+    objectExpression.loc && objectExpression.loc.start.line !== objectExpression.loc.end.line,
+  );
+
+  if (!isMultiline) {
+    const existingText = properties.map((property) => sourceCode.getText(property));
+    return existingText.length === 0 ? `{ ${entryText} }` : `{ ${existingText.join(', ')}, ${entryText} }`;
+  }
+
+  const openingBrace = sourceCode.getFirstToken(objectExpression);
+  const closingBrace = sourceCode.getLastToken(objectExpression);
+  const closingIndent = closingBrace ? getIndent(sourceCode, closingBrace) : '';
+  const propertyIndent = properties[0] ? getIndent(sourceCode, properties[0]) : `${closingIndent}  `;
+  const existingText = properties.map((property) => `${propertyIndent}${sourceCode.getText(property)}`);
+
+  if (existingText.length === 0) {
+    return `{
+${propertyIndent}${entryText}
+${closingIndent}}`;
+  }
+
+  return `{
+${existingText.join(',\n')},
+${propertyIndent}${entryText}
+${closingIndent}}`;
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} objectExpression
+ */
+const hasTrailingComma = (sourceCode, objectExpression) => {
+  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
+  const lastProperty = properties[properties.length - 1];
+  if (!lastProperty) return false;
+
+  const tokenAfter = sourceCode.getTokenAfter(lastProperty);
+  return Boolean(tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',');
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} decoratorNode
+ * @param {any} memberNode
+ * @param {string} bindingKey
+ * @param {string} memberName
+ */
+const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey, memberName) => {
+  const classBody = memberNode.parent;
+  const classNode = classBody?.parent;
+  if (!classNode) return null;
+
+  const metadata = getAngularMetadata(classNode);
+  if (!metadata) return null;
+
+  const hostProperty = findObjectProperty(metadata, 'host');
+  const hostEntryText = `'${bindingKey}': '${memberName}'`;
+  const fixes = [];
+
+  if (hostProperty) {
+    if (hostProperty.value.type !== 'ObjectExpression') return null;
+    if (
+      hostProperty.value.properties.some(
+        (property) => property.type === 'Property' && getPropertyName(property.key) === bindingKey,
+      )
+    ) {
+      return null;
+    }
+
+    fixes.push((fixer) =>
+      fixer.replaceText(
+        hostProperty.value,
+        buildObjectTextWithAppendedProperty(sourceCode, hostProperty.value, hostEntryText),
+      ),
+    );
+  } else {
+    const closingBrace = sourceCode.getLastToken(metadata);
+    if (!closingBrace) return null;
+
+    const isMultiline = Boolean(metadata.loc && metadata.loc.start.line !== metadata.loc.end.line);
+    const closingIndent = getIndent(sourceCode, closingBrace);
+    const propertyIndent = metadata.properties[0]
+      ? getIndent(sourceCode, metadata.properties[0])
+      : `${getIndent(sourceCode, closingBrace)}  `;
+    const hostPropertyText = `host: { ${hostEntryText} }`;
+    const separator = metadata.properties.length > 0 ? (hasTrailingComma(sourceCode, metadata) ? '' : ',') : '';
+
+    if (isMultiline && metadata.properties.length > 0) {
+      const lastProperty = metadata.properties[metadata.properties.length - 1];
+      const tokenAfterLastProperty = sourceCode.getTokenAfter(lastProperty);
+      const rangeStart =
+        separator === '' && tokenAfterLastProperty ? tokenAfterLastProperty.range[1] : lastProperty.range[1];
+
+      fixes.push((fixer) =>
+        fixer.replaceTextRange(
+          [rangeStart, closingBrace.range[0]],
+          `${separator}\n${propertyIndent}${hostPropertyText},\n${closingIndent}`,
+        ),
+      );
+    } else {
+      const insertion = isMultiline
+        ? `\n${propertyIndent}${hostPropertyText}\n${closingIndent}`
+        : `${metadata.properties.length > 0 ? `${separator} ` : ' '}${hostPropertyText}${metadata.properties.length > 0 ? '' : ' '}`;
+
+      fixes.push((fixer) => fixer.insertTextBefore(closingBrace, insertion));
+    }
+  }
+
+  const nextToken = sourceCode.getTokenAfter(decoratorNode);
+  fixes.push(
+    nextToken
+      ? (fixer) => fixer.removeRange([decoratorNode.range[0], nextToken.range[0]])
+      : (fixer) => fixer.remove(decoratorNode),
+  );
+
+  return (fixer) => fixes.map((applyFix) => applyFix(fixer));
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const rule = {
   meta: {
@@ -59,6 +233,7 @@ const rule = {
       description:
         'Disallow legacy Angular decorators (@Input, @Output, @ViewChild, etc.) in favour of signal-based APIs and host: {} bindings.',
     },
+    fixable: 'code',
     schema: [],
     messages: {
       useInput: 'Use the input() signal function instead of @Input().',
@@ -195,7 +370,27 @@ const rule = {
             break;
 
           case 'HostBinding':
-            context.report({ node, messageId: 'useHostBinding' });
+            context.report({
+              node,
+              messageId: 'useHostBinding',
+              fix: (() => {
+                const memberName = getMemberName(parent);
+                if (!memberName) return null;
+
+                const expression = anyNode.expression;
+                if (expression.type !== 'CallExpression' && expression.type !== 'Identifier') return null;
+
+                const bindingName =
+                  expression.type === 'CallExpression'
+                    ? expression.arguments[0]?.type === 'Literal' && typeof expression.arguments[0].value === 'string'
+                      ? expression.arguments[0].value
+                      : memberName
+                    : memberName;
+
+                const bindingKey = bindingName.startsWith('[') ? bindingName : `[${bindingName}]`;
+                return buildHostBindingFix(context.sourceCode, anyNode, parent, bindingKey, memberName);
+              })(),
+            });
             break;
 
           case 'HostListener':

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

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getMemberName, isReferencedFromTemplateOrHost } = require('./internals/angular-member-visibility');
+
 /**
  * @param {any} node
  */
@@ -18,19 +20,63 @@ const noPublicProperty = {
         '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.',
+      shouldBeProtected:
+        'Member `{{name}}` should be protected instead of public because it is referenced from a template or host binding.',
     },
   },
   create(context) {
+    /**
+     * @param {any} node
+     */
+    const removePublicFix = (node) => {
+      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) => fixer.removeRange([publicToken.range[0], nextToken.range[0]]);
+    };
+
+    /**
+     * @param {any} node
+     */
+    const replacePublicWithProtectedFix = (node) => {
+      const publicToken = context.sourceCode.getFirstToken(node, (token) => token.value === 'public');
+      if (!publicToken) return null;
+
+      return (fixer) => fixer.replaceText(publicToken, 'protected');
+    };
+
     return {
       PropertyDefinition(node) {
         if (node.accessibility !== 'public') return;
         if (isInjectCall(node.value)) return;
 
-        context.report({ node, messageId: 'noPublicProperty' });
+        const classNode = node.parent && node.parent.type === 'ClassBody' ? node.parent.parent : null;
+        const memberName = getMemberName(node);
+        const isTemplateVisible =
+          classNode && memberName ? isReferencedFromTemplateOrHost(classNode, memberName, context) : false;
+
+        if (isTemplateVisible) {
+          context.report({
+            node,
+            messageId: 'shouldBeProtected',
+            data: { name: memberName },
+            fix: replacePublicWithProtectedFix(node),
+          });
+
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: 'noPublicProperty',
+          fix: removePublicFix(node),
+        });
       },
     };
   },

package/src/rules/no-redundant-internal.js

@@ -0,0 +1,94 @@
+// @ts-check
+'use strict';
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('eslint').Rule.Node} node
+ */
+const getAttachedInternalComment = (sourceCode, node) => {
+  const comments = sourceCode.getCommentsBefore(node);
+  const attachedComment = comments[comments.length - 1];
+
+  if (!attachedComment || attachedComment.type !== 'Block') {
+    return null;
+  }
+
+  const textBetween = sourceCode.text.slice(attachedComment.range[1], node.range[0]);
+
+  if (textBetween.trim() !== '') {
+    return null;
+  }
+
+  return /@internal\b/u.test(attachedComment.value) ? attachedComment : null;
+};
+
+/**
+ * @param {any} node
+ */
+const getMemberName = (node) => {
+  if (node.key?.type === 'Identifier') return node.key.name;
+  if (node.key?.type === 'Literal' && typeof node.key.value === 'string') return node.key.value;
+
+  return 'member';
+};
+
+/**
+ * @param {any} node
+ */
+const getMemberKind = (node) => {
+  if (node.type === 'MethodDefinition') return 'method';
+  return 'property';
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noRedundantInternal = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow redundant @internal usage on class members that are already hidden by accessibility.',
+      recommended: true,
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      redundantInternal:
+        '`@internal` is redundant on {{kind}} `{{name}}` because {{accessibility}} members are already hidden from consumers.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    /**
+     * @param {any} node
+     */
+    const checkMember = (node) => {
+      const internalComment = getAttachedInternalComment(sourceCode, node);
+
+      if (!internalComment) {
+        return;
+      }
+
+      if (node.accessibility !== 'private' && node.accessibility !== 'protected') {
+        return;
+      }
+
+      context.report({
+        node: internalComment,
+        messageId: 'redundantInternal',
+        data: {
+          accessibility: node.accessibility,
+          kind: getMemberKind(node),
+          name: getMemberName(node),
+        },
+        fix: (fixer) => fixer.removeRange([internalComment.range[0], node.range[0]]),
+      });
+    };
+
+    return {
+      PropertyDefinition: checkMember,
+      MethodDefinition: checkMember,
+    };
+  },
+};
+
+module.exports = noRedundantInternal;

package/src/rules/no-standalone-flag.js

@@ -0,0 +1,95 @@
+// @ts-check
+'use strict';
+
+/** @typedef {'Component' | 'Directive' | 'Pipe'} TDecoratorName */
+
+/**
+ * @param {import('estree').Property['key']} key
+ */
+const getPropertyName = (key) => {
+  if (key.type === 'Identifier') return key.name;
+  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
+/**
+ * @param {import('eslint').Rule.Node} node
+ * @returns {TDecoratorName | null}
+ */
+const getDecoratorName = (node) => {
+  const decorator = /** @type {any} */ (node);
+  if (decorator.type !== 'Decorator') return null;
+
+  const expression = decorator.expression;
+  if (expression.type === 'CallExpression') {
+    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
+  }
+
+  return expression.type === 'Identifier' ? expression.name : null;
+};
+
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} metadata
+ * @param {any} property
+ */
+const getRemovalRange = (sourceCode, metadata, property) => {
+  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
+  const propertyIndex = properties.indexOf(property);
+  const openingBrace = sourceCode.getFirstToken(metadata);
+  const closingBrace = sourceCode.getLastToken(metadata);
+
+  if (!openingBrace || !closingBrace) return property.range;
+  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
+  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
+
+  return [properties[propertyIndex - 1].range[1], property.range[1]];
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noStandaloneFlag = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Disallow standalone metadata on Angular decorators because standalone is the default and should be omitted.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noStandalone: 'Remove standalone from Angular metadata. Standalone is implicit and should not be declared.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      Decorator(node) {
+        const decoratorName = getDecoratorName(node);
+        if (decoratorName !== 'Component' && decoratorName !== 'Directive' && decoratorName !== 'Pipe') return;
+
+        const decorator = /** @type {any} */ (node);
+        const expression = decorator.expression;
+        if (expression.type !== 'CallExpression' || expression.arguments.length === 0) return;
+
+        const metadata = expression.arguments[0];
+        if (!metadata || metadata.type !== 'ObjectExpression') return;
+
+        for (const property of metadata.properties) {
+          if (property.type !== 'Property') continue;
+          if (getPropertyName(property.key) !== 'standalone') continue;
+
+          context.report({
+            node: property,
+            messageId: 'noStandalone',
+            fix(fixer) {
+              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noStandaloneFlag;

package/src/rules/no-typed-injected-element-ref.js

@@ -0,0 +1,88 @@
+// @ts-check
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noTypedInjectedElementRef = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Require that inject(ElementRef) uses a generic type parameter on inject() itself, not on ElementRef.',
+      recommended: true,
+    },
+    messages: {
+      missingGeneric:
+        'Provide a generic type on inject() itself: `inject<ElementRef<HTMLElement>>(ElementRef)`. Passing a type argument on ElementRef directly is also disallowed.',
+    },
+    schema: [],
+    fixable: 'code',
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+        if (!firstArg) return;
+
+        const isPlainElementRef = firstArg.type === 'Identifier' && firstArg.name === 'ElementRef';
+        const isInstantiatedElementRef =
+          firstArg.type === 'TSInstantiationExpression' &&
+          firstArg.expression &&
+          firstArg.expression.type === 'Identifier' &&
+          firstArg.expression.name === 'ElementRef';
+
+        if (!isPlainElementRef && !isInstantiatedElementRef) return;
+
+        const src = context.sourceCode;
+        const existingTypeParams = node.typeParameters || node.typeArguments;
+        const hasInjectTypeParam =
+          existingTypeParams && existingTypeParams.params && existingTypeParams.params.length > 0;
+
+        if (isPlainElementRef && !hasInjectTypeParam) {
+          // inject(ElementRef) → inject<ElementRef<HTMLElement>>(ElementRef)
+          context.report({
+            node,
+            messageId: 'missingGeneric',
+            fix(fixer) {
+              return fixer.insertTextAfter(node.callee, '<ElementRef<HTMLElement>>');
+            },
+          });
+          return;
+        }
+
+        if (isInstantiatedElementRef) {
+          // Capture the type args text from the token, e.g. "<HTMLElement>"
+          const tokenTypeParamText = src.getText(firstArg.typeParameters || firstArg.typeArguments);
+
+          if (!hasInjectTypeParam) {
+            // inject(ElementRef<HTMLElement>) → inject<ElementRef<HTMLElement>>(ElementRef)
+            context.report({
+              node,
+              messageId: 'missingGeneric',
+              fix(fixer) {
+                return [
+                  fixer.insertTextAfter(node.callee, `<ElementRef${tokenTypeParamText}>`),
+                  fixer.replaceText(firstArg, 'ElementRef'),
+                ];
+              },
+            });
+          } else {
+            // inject<X>(ElementRef<Y>) — token must not carry type args; keep inject's type param
+            context.report({
+              node,
+              messageId: 'missingGeneric',
+              fix(fixer) {
+                return fixer.replaceText(firstArg, 'ElementRef');
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+module.exports = noTypedInjectedElementRef;