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

package/CHANGELOG.md

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

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',
@@ -269,6 +275,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 +313,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 +323,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 +340,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)

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');
@@ -35,6 +36,10 @@ 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 preferConciseAngularHostDirectives = require('./rules/prefer-concise-angular-host-directives');
 const preferConciseAngularStyleMetadata = require('./rules/prefer-concise-angular-style-metadata');
@@ -68,6 +73,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,
@@ -81,6 +87,10 @@ const plugin = {
     '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,
     'prefer-concise-angular-host-directives': preferConciseAngularHostDirectives,
     'prefer-concise-angular-style-metadata': preferConciseAngularStyleMetadata,

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/inject-member-accessibility.js

@@ -89,6 +89,19 @@ const readFileIfExists = (filePath) => {
   return null;
 };
 
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ */
+const getContextFilename = (context) => {
+  const filename = context.physicalFilename || context.filename;
+
+  if (!filename || filename === '<input>' || filename === '<text>') {
+    return null;
+  }
+
+  return filename;
+};
+
 /**
  * @param {string} memberName
  * @param {string | null} template
@@ -100,6 +113,9 @@ const templateReferencesMember = (memberName, template) => {
   const patterns = [
     new RegExp(`\\{\\{[\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\}\\}`, 'u'),
     new RegExp(`@[a-zA-Z]+\\s*\\([\\s\\S]*?\\b${escapedName}\\b[\\s\\S]*?\\)`, 'u'),
+    new RegExp(`@let\\s+[a-zA-Z_$][\\w$]*\\s*=\\s*[\\s\\S]*?\\b${escapedName}\\b`, 'u'),
+    new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
+    new RegExp(`\\*[a-zA-Z0-9_\\-]+\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
     new RegExp(`\\[[^\\]]+\\]\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
     new RegExp(`\\[[^\\]]+\\]\\s*=\\s*'[^']*\\b${escapedName}\\b[^']*'`, 'u'),
     new RegExp(`\\([^\\)]+\\)\\s*=\\s*"[^"]*\\b${escapedName}\\b[^"]*"`, 'u'),
@@ -160,8 +176,10 @@ const isReferencedFromTemplateOrHost = (memberName, metadata, context) => {
   const templateUrlProperty = getMetadataProperty(metadata, 'templateUrl');
   if (templateUrlProperty) {
     const templateUrl = getStringValue(templateUrlProperty.value);
-    if (templateUrl) {
-      const templatePath = path.resolve(path.dirname(context.filename), templateUrl);
+    const filename = getContextFilename(context);
+
+    if (templateUrl && filename) {
+      const templatePath = path.resolve(path.dirname(filename), templateUrl);
       const templateText = readFileIfExists(templatePath);
       if (templateReferencesMember(memberName, templateText)) {
         return true;

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -0,0 +1,104 @@
+// @ts-check
+'use strict';
+
+/** @typedef {'Component' | 'Directive'} 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]];
+};
+
+const MESSAGE_IDS = {
+  hostDirectives: 'noEmptyHostDirectives',
+  imports: 'noEmptyImports',
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEmptyAngularMetadataArrays = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow empty Angular metadata arrays such as imports: [] and hostDirectives: [].',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noEmptyImports: 'Remove empty imports: [] from Angular metadata.',
+      noEmptyHostDirectives: 'Remove empty hostDirectives: [] from Angular metadata.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      /** @param {import('eslint').Rule.Node} node */
+      Decorator(node) {
+        const decoratorName = getDecoratorName(node);
+        if (decoratorName !== 'Component' && decoratorName !== 'Directive') 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;
+
+          const propertyName = getPropertyName(property.key);
+          if (propertyName !== 'imports' && propertyName !== 'hostDirectives') continue;
+          if (property.value.type !== 'ArrayExpression' || property.value.elements.length > 0) continue;
+
+          context.report({
+            node: property,
+            messageId: MESSAGE_IDS[propertyName],
+            fix(fixer) {
+              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noEmptyAngularMetadataArrays;

package/src/rules/no-empty-newlines-between-imports.js

@@ -0,0 +1,45 @@
+// @ts-check
+'use strict';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEmptyNewlinesBetweenImports = {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Disallow empty blank lines between consecutive import declarations.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      noEmptyLine: 'Remove empty blank lines between import declarations.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      Program(node) {
+        const importDeclarations = node.body.filter((statement) => statement.type === 'ImportDeclaration');
+
+        for (let index = 1; index < importDeclarations.length; index += 1) {
+          const previousImport = importDeclarations[index - 1];
+          const currentImport = importDeclarations[index];
+          const textBetween = sourceCode.text.slice(previousImport.range[1], currentImport.range[0]);
+
+          if (/\S/.test(textBetween)) continue;
+          if (!/\n\s*\n/.test(textBetween)) continue;
+
+          context.report({
+            node: currentImport,
+            messageId: 'noEmptyLine',
+            fix(fixer) {
+              return fixer.replaceTextRange([previousImport.range[1], currentImport.range[0]], '\n');
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = noEmptyNewlinesBetweenImports;

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':