@simplysm/lint 13.0.100 → 14.0.4

package/src/rules/ng-template-no-todo-comments.ts

@@ -0,0 +1,48 @@
+import { createRule } from "../utils/create-rule";
+
+/**
+ * HTML 템플릿 내 TODO 주석을 감지하여 경고하는 ESLint 규칙.
+ *
+ * @remarks
+ * `<!-- TODO: ... -->` 형태의 HTML 주석을 찾아 보고합니다.
+ * raw text regex 방식으로 동작하므로 AST 노드 방문자가 아닌 빈 객체를 반환합니다.
+ */
+export default createRule({
+  name: "ng-template-no-todo-comments",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "HTML 템플릿 내 TODO 주석을 경고합니다.",
+    },
+    schema: [],
+    messages: {
+      noTodo: "{{content}}",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const source = sourceCode.getText();
+    const commentRegex = /<!--([\s\S]*?)-->/g;
+    let match;
+    while ((match = commentRegex.exec(source)) !== null) {
+      const commentContent = match[1];
+      const todoIndex = commentContent.indexOf("TODO:");
+      if (todoIndex < 0) continue;
+
+      const start = match.index;
+      const end = start + match[0].length;
+      const content = commentContent.slice(todoIndex + 5).trim();
+      const loc = sourceCode.getLocFromIndex(start);
+      const endLoc = sourceCode.getLocFromIndex(end);
+
+      context.report({
+        loc: { start: loc, end: endLoc },
+        messageId: "noTodo",
+        data: { content },
+      });
+    }
+
+    return {};
+  },
+});

package/src/rules/ng-template-sd-require-binding-attrs.ts

@@ -0,0 +1,111 @@
+import { getTemplateParserServices } from "@angular-eslint/utils";
+import { createRule } from "../utils/create-rule";
+
+export interface RuleOptions {
+  selectorPrefixes?: string[];
+  allowAttributes?: string[];
+  allowAttributePrefixes?: string[];
+}
+
+const DEFAULT_OPTIONS: Required<RuleOptions> = {
+  selectorPrefixes: ["sd-"],
+  allowAttributes: ["id", "class", "style", "title", "tabindex", "role"],
+  allowAttributePrefixes: ["aria-", "data-", "sd-"],
+};
+
+/**
+ * sd-* 컴포넌트에서 plain attribute 사용을 제한하고 Angular property binding을 강제하는 ESLint 규칙.
+ *
+ * @remarks
+ * `sd-` 접두사를 가진 커스텀 컴포넌트에서 허용되지 않은 plain attribute를 감지합니다.
+ * 허용 목록(id, class, style, title, tabindex, role)과 허용 접두사(aria-, data-, sd-)에
+ * 해당하지 않는 attribute는 `[attr]="..."` 형태의 property binding으로 변환하도록 autofix합니다.
+ */
+export default createRule({
+  name: "ng-template-sd-require-binding-attrs",
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'Disallow non-whitelisted plain attributes on prefixed components (e.g. sd-*) and require using Angular property bindings instead.',
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          selectorPrefixes: { type: "array", items: { type: "string" } },
+          allowAttributes: { type: "array", items: { type: "string" } },
+          allowAttributePrefixes: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      requireBindingForAttribute:
+        'Attribute "{{attrName}}" is not allowed as a plain attribute on "{{elementName}}". Use a property binding instead, e.g. [{{attrName}}]="…".',
+    },
+  },
+  defaultOptions: [{}] as [RuleOptions],
+  create(context) {
+    const parserServices = getTemplateParserServices(context as never);
+    const userOptions = context.options.at(0) ?? {};
+    const selectorPrefixes = userOptions.selectorPrefixes ?? DEFAULT_OPTIONS.selectorPrefixes;
+    const allowAttributes = userOptions.allowAttributes ?? DEFAULT_OPTIONS.allowAttributes;
+    const allowAttributePrefixes =
+      userOptions.allowAttributePrefixes ?? DEFAULT_OPTIONS.allowAttributePrefixes;
+
+    const allowedAttrSet = new Set(allowAttributes.map((attr) => attr.toLowerCase()));
+
+    function isTargetElement(node: { name: string }): boolean {
+      const tagName = node.name.toLowerCase();
+      return selectorPrefixes.some((prefix) => tagName.startsWith(prefix.toLowerCase()));
+    }
+
+    function isWhitelistedPlainAttr(attr: { name: string }): boolean {
+      const name = attr.name.toLowerCase();
+      if (allowedAttrSet.has(name)) return true;
+      return allowAttributePrefixes.some((prefix) => name.startsWith(prefix.toLowerCase()));
+    }
+
+    return {
+      Element(node: {
+        name: string;
+        attributes: Array<{
+          name: string;
+          value: string;
+          sourceSpan: { start: { offset: number }; end: { offset: number } };
+        }>;
+        sourceSpan: { start: { offset: number }; end: { offset: number } };
+      }) {
+        if (!isTargetElement(node)) return;
+
+        for (const attr of node.attributes) {
+          if (isWhitelistedPlainAttr(attr)) continue;
+
+          const span = attr.sourceSpan;
+          const loc = parserServices.convertNodeSourceSpanToLoc(span as never);
+
+          context.report({
+            loc,
+            messageId: "requireBindingForAttribute",
+            data: { attrName: attr.name, elementName: node.name },
+            fix(fixer) {
+              const start = span.start.offset;
+              const end = span.end.offset;
+              if (start >= end) return null;
+
+              const rawValue = attr.value;
+              if (rawValue === "") {
+                return fixer.replaceTextRange([start, end], `[${attr.name}]="true"`);
+              }
+
+              const escaped = rawValue.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+              return fixer.replaceTextRange([start, end], `[${attr.name}]="'${escaped}'"`);
+            },
+          });
+        }
+      },
+    } as never;
+  },
+});

package/src/rules/no-hard-private.ts

@@ -18,27 +18,27 @@ function isClassMemberWithAccessibility(
 }
 
 /**
- * ESLint rule that restricts ECMAScript private fields (`#field`) and enforces TypeScript `private` keyword usage.
+ * ECMAScript private 필드(`#field`)를 제한하고 TypeScript `private` 키워드 사용을 강제하는 ESLint 규칙.
  *
  * @remarks
- * This rule checks:
- * - Class field declarations: `#field`
- * - Class method declarations: `#method()`
- * - Class accessor declarations: `accessor #field`
- * - Member access expressions: `this.#field`
+ * 이 규칙이 검사하는 항목:
+ * - 클래스 필드 선언: `#field`
+ * - 클래스 메서드 선언: `#method()`
+ * - 클래스 접근자 선언: `accessor #field`
+ * - 멤버 접근 표현식: `this.#field`
  */
 export default createRule({
   name: "no-hard-private",
   meta: {
     type: "problem",
     docs: {
-      description: 'Enforces TypeScript "private _" style instead of hard private fields (#).',
+      description: 'hard private 필드(#) 대신 TypeScript "private _" 스타일을 강제합니다.',
     },
     messages: {
       preferSoftPrivate:
-        'Hard private fields (#) are not allowed. Use the "private _" style instead.',
+        'hard private 필드(#)는 사용할 수 없습니다. "private _" 스타일을 사용하세요.',
       nameConflict:
-        'Cannot convert hard private field "#{{name}}" to "_{{name}}". A member with the same name already exists.',
+        'hard private 필드 "#{{name}}"을(를) "_{{name}}"(으)로 변환할 수 없습니다. 동일한 이름의 멤버가 이미 존재합니다.',
     },
     fixable: "code",
     schema: [],
@@ -46,11 +46,11 @@ export default createRule({
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
-    // Stack structure for supporting nested classes
+    // 중첩 클래스 지원을 위한 스택 구조
     const classStack: Set<string>[] = [];
 
     return {
-      // 0. Collect member names when entering a class
+      // 0. 클래스 진입 시 멤버 이름 수집
       "ClassBody"(node: TSESTree.ClassBody) {
         const memberNames = new Set<string>();
         for (const member of node.body) {
@@ -67,7 +67,7 @@ export default createRule({
         classStack.pop();
       },
 
-      // 1. Detect declarations (PropertyDefinition, MethodDefinition, AccessorProperty)
+      // 1. 선언 감지 (PropertyDefinition, MethodDefinition, AccessorProperty)
       "PropertyDefinition > PrivateIdentifier, MethodDefinition > PrivateIdentifier, AccessorProperty > PrivateIdentifier"(
         node: TSESTree.PrivateIdentifier,
       ) {
@@ -76,11 +76,11 @@ export default createRule({
           return;
         }
 
-        const identifierName = node.name; // Name without the '#' character
+        const identifierName = node.name; // '#' 문자를 제외한 이름
         const targetName = `_${identifierName}`;
         const currentClassMembers = classStack.at(-1);
 
-        // Check for name conflicts
+        // 이름 충돌 확인
         if (currentClassMembers?.has(targetName)) {
           context.report({
             node,
@@ -96,25 +96,25 @@ export default createRule({
           fix(fixer) {
             const fixes: RuleFix[] = [];
 
-            // 1-1. Rename (#a -> _a)
+            // 1-1. 이름 변경 (#a -> _a)
             fixes.push(fixer.replaceText(node, targetName));
 
-            // 1-2. Calculate the position to add the 'private' access modifier
+            // 1-2. 'private' 접근 제어자를 추가할 위치 계산
             if (parent.accessibility == null) {
-              // Default insertion position: beginning of parent node (including static, async, etc)
+              // 기본 삽입 위치: 부모 노드의 시작 (static, async 등 포함)
               let tokenToInsertBefore = sourceCode.getFirstToken(parent);
 
-              // If decorators exist, insert before the token after the last decorator
+              // 데코레이터가 있으면 마지막 데코레이터 다음 토큰 앞에 삽입
               // (@Deco private static _foo)
               if (parent.decorators.length > 0) {
                 const lastDecorator = parent.decorators.at(-1)!;
                 tokenToInsertBefore = sourceCode.getTokenAfter(lastDecorator);
               }
 
-              // tokenToInsertBefore is now 'static', 'async', 'readonly', or a variable name ('_foo').
-              // Inserting 'private ' before it naturally results in the correct order 'private static ...'.
-              // If tokenToInsertBefore is null, it indicates an exceptional situation such as an AST parsing error.
-              // In such cases, skip the entire fix to prevent an incomplete fix that only renames.
+              // tokenToInsertBefore는 현재 'static', 'async', 'readonly', 또는 변수명('_foo')입니다.
+              // 앞에 'private '를 삽입하면 자연스럽게 'private static ...' 순서가 됩니다.
+              // tokenToInsertBefore가 null이면 AST 파싱 오류 등의 예외 상황을 나타냅니다.
+              // 이런 경우 이름만 변경되는 불완전한 수정을 방지하기 위해 전체 수정을 건너뜁니다.
               if (tokenToInsertBefore == null) {
                 return [];
               }
@@ -126,7 +126,7 @@ export default createRule({
         });
       },
 
-      // 2. Detect usage (this.#field)
+      // 2. 사용 감지 (this.#field)
       "MemberExpression > PrivateIdentifier"(node: TSESTree.PrivateIdentifier) {
         const identifierName = node.name;
         context.report({

package/src/rules/no-subpath-imports-from-simplysm.ts

@@ -2,13 +2,13 @@ import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
 import { createRule } from "../utils/create-rule";
 
 /**
- * ESLint rule that prohibits 'src' subpath imports from `@simplysm/*` packages.
+ * `@simplysm/*` 패키지에서 'src' 하위 경로 import를 금지하는 ESLint 규칙.
  *
  * @remarks
- * This rule checks:
- * - Static import statements: `import ... from '...'`
- * - Dynamic imports: `import('...')`
- * - Re-export statements: `export { ... } from '...'`, `export * from '...'`
+ * 이 규칙이 검사하는 항목:
+ * - 정적 import 문: `import ... from '...'`
+ * - 동적 import: `import('...')`
+ * - 재내보내기 문: `export { ... } from '...'`, `export * from '...'`
  */
 export default createRule({
   name: "no-subpath-imports-from-simplysm",
@@ -16,13 +16,13 @@ export default createRule({
     type: "problem",
     docs: {
       description:
-        "Prohibits 'src' subpath imports from @simplysm packages. (e.g., @simplysm/pkg/src/x → prohibited)",
+        "@simplysm 패키지에서 'src' 하위 경로 import를 금지합니다. (예: @simplysm/pkg/src/x → 금지)",
     },
     fixable: "code",
     schema: [],
     messages: {
       noSubpathImport:
-        "Cannot import 'src' subpath from '@simplysm/{{pkg}}' package: '{{importPath}}'",
+        "'@simplysm/{{pkg}}' 패키지에서 'src' 하위 경로를 import할 수 없습니다: '{{importPath}}'",
     },
   },
   defaultOptions: [],
@@ -32,8 +32,8 @@ export default createRule({
 
       const parts = importPath.split("/");
 
-      // Allowed: @simplysm/pkg, @simplysm/pkg/xxx, @simplysm/pkg/xxx/yyy
-      // Prohibited: @simplysm/pkg/src, @simplysm/pkg/src/xxx
+      // 허용: @simplysm/pkg, @simplysm/pkg/xxx, @simplysm/pkg/xxx/yyy
+      // 금지: @simplysm/pkg/src, @simplysm/pkg/src/xxx
       if (parts.length >= 3 && parts[2] === "src") {
         const fixedPath = `@simplysm/${parts[1]}`;
         context.report({
@@ -52,12 +52,12 @@ export default createRule({
     }
 
     return {
-      // Static import: import { x } from '...'
+      // 정적 import: import { x } from '...'
       ImportDeclaration(node) {
         checkAndReport(node.source, node.source.value);
       },
 
-      // Dynamic import: import('...')
+      // 동적 import: import('...')
       ImportExpression(node) {
         if (node.source.type !== AST_NODE_TYPES.Literal) return;
         const importPath = node.source.value;
@@ -65,13 +65,13 @@ export default createRule({
         checkAndReport(node.source, importPath);
       },
 
-      // Re-export: export { x } from '...'
+      // 재내보내기: export { x } from '...'
       ExportNamedDeclaration(node) {
         if (!node.source) return;
         checkAndReport(node.source, node.source.value);
       },
 
-      // Re-export all: export * from '...'
+      // 전체 재내보내기: export * from '...'
       ExportAllDeclaration(node) {
         checkAndReport(node.source, node.source.value);
       },

package/src/rules/ts-no-throw-not-implemented-error.ts

@@ -2,25 +2,25 @@ import { AST_NODE_TYPES, ASTUtils, type TSESTree } from "@typescript-eslint/util
 import { createRule } from "../utils/create-rule";
 
 /**
- * ESLint rule that detects and warns about the use of `NotImplementedError` from `@simplysm/core-common`.
+ * `@simplysm/core-common`의 `NotImplementedError` 사용을 감지하고 경고하는 ESLint 규칙.
  *
  * @remarks
- * This rule detects code that instantiates `NotImplementedError` imported from `@simplysm/core-common` using `new`.
- * It prevents unimplemented code from being included in production.
+ * `@simplysm/core-common`에서 import한 `NotImplementedError`를 `new`로 인스턴스화하는 코드를 감지합니다.
+ * 미구현 코드가 프로덕션에 포함되는 것을 방지합니다.
  *
- * Supported import forms:
+ * 지원하는 import 형태:
  * - named import: `import { NotImplementedError } from "@simplysm/core-common"`
  * - aliased import: `import { NotImplementedError as NIE } from "@simplysm/core-common"`
  * - namespace import: `import * as CC from "@simplysm/core-common"` → `new CC.NotImplementedError()`
  *
- * Dynamic imports (`await import(...)`) are not detected.
+ * 동적 import (`await import(...)`)는 감지하지 않습니다.
  */
 export default createRule({
   name: "ts-no-throw-not-implemented-error",
   meta: {
     type: "suggestion",
     docs: {
-      description: "Warns about 'NotImplementedError' usage",
+      description: "'NotImplementedError' 사용에 대해 경고합니다",
     },
     schema: [],
     messages: {
@@ -30,10 +30,10 @@ export default createRule({
   defaultOptions: [],
   create(context) {
     /**
-     * Checks if an identifier is imported from @simplysm/core-common.
-     * @param identifier - The identifier to check
-     * @param expectedImportedName - The original name to check for named imports (undefined for namespace imports)
-     * @returns true if the import source is @simplysm/core-common, false otherwise
+     * 식별자가 @simplysm/core-common에서 import되었는지 확인합니다.
+     * @param identifier - 확인할 식별자
+     * @param expectedImportedName - named import에서 확인할 원래 이름 (namespace import의 경우 undefined)
+     * @returns import 소스가 @simplysm/core-common이면 true, 아니면 false
      */
     function isImportedFromSimplysm(
       identifier: TSESTree.Identifier,
@@ -48,7 +48,7 @@ export default createRule({
         if (def.parent.type !== AST_NODE_TYPES.ImportDeclaration) continue;
         if (def.parent.source.value !== "@simplysm/core-common") continue;
 
-        // named/aliased import: import { NotImplementedError } or import { NotImplementedError as NIE }
+        // named/aliased import: import { NotImplementedError } 또는 import { NotImplementedError as NIE }
         if (def.node.type === AST_NODE_TYPES.ImportSpecifier && expectedImportedName != null) {
           const imported = def.node.imported;
           if (
@@ -75,12 +75,12 @@ export default createRule({
       NewExpression(node: TSESTree.NewExpression) {
         let shouldReport = false;
 
-        // Case 1: new NotImplementedError() or new NIE() (named/aliased import)
+        // 케이스 1: new NotImplementedError() 또는 new NIE() (named/aliased import)
         if (node.callee.type === AST_NODE_TYPES.Identifier) {
           shouldReport = isImportedFromSimplysm(node.callee, "NotImplementedError");
         }
 
-        // Case 2: new CC.NotImplementedError() (namespace import)
+        // 케이스 2: new CC.NotImplementedError() (namespace import)
         else if (
           node.callee.type === AST_NODE_TYPES.MemberExpression &&
           node.callee.property.type === AST_NODE_TYPES.Identifier &&
@@ -92,7 +92,7 @@ export default createRule({
 
         if (!shouldReport) return;
 
-        let msg = "Not implemented";
+        let msg = "미구현";
         const firstArg = node.arguments.at(0);
         if (
           firstArg?.type === AST_NODE_TYPES.Literal &&

package/src/rules/ts-no-unused-injects.ts

@@ -0,0 +1,88 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule";
+
+function traverseNode(node: TSESTree.Node, callback: (n: TSESTree.Node) => void): void {
+  callback(node);
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = (node as unknown as Record<string, unknown>)[key];
+    if (Array.isArray(child)) {
+      for (const c of child) {
+        if (c != null && typeof c === "object" && "type" in c) {
+          traverseNode(c as TSESTree.Node, callback);
+        }
+      }
+    } else if (child != null && typeof child === "object" && "type" in child) {
+      traverseNode(child as TSESTree.Node, callback);
+    }
+  }
+}
+
+/**
+ * 미사용 Angular `inject()` 필드를 감지하는 ESLint 규칙.
+ *
+ * @remarks
+ * 클래스 내에서 `inject()` 호출로 초기화된 프로퍼티 중
+ * 같은 클래스 내 다른 곳에서 참조되지 않는 필드를 보고합니다.
+ * autofix로 해당 필드를 제거합니다.
+ */
+export default createRule({
+  name: "ts-no-unused-injects",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused Angular inject() fields",
+    },
+    fixable: "code",
+    messages: {
+      unusedInject: 'inject() field "{{name}}" is never used.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ClassBody(classBody: TSESTree.ClassBody) {
+        const injectFields = classBody.body.filter(
+          (node): node is TSESTree.PropertyDefinition =>
+            node.type === AST_NODE_TYPES.PropertyDefinition &&
+            node.value != null &&
+            node.value.type === AST_NODE_TYPES.CallExpression &&
+            node.value.callee.type === AST_NODE_TYPES.Identifier &&
+            node.value.callee.name === "inject" &&
+            node.key.type === AST_NODE_TYPES.Identifier,
+        );
+
+        for (const field of injectFields) {
+          const fieldName = (field.key as TSESTree.Identifier).name;
+
+          const allIdentifiers: TSESTree.Identifier[] = [];
+          traverseNode(classBody, (node) => {
+            if (node.type === AST_NODE_TYPES.Identifier && node.name === fieldName) {
+              allIdentifiers.push(node);
+            }
+          });
+
+          const references = allIdentifiers.filter((id) => id !== field.key);
+
+          if (references.length === 0) {
+            context.report({
+              node: field,
+              messageId: "unusedInject",
+              data: { name: fieldName },
+              fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(field);
+                const tokenAfter = sourceCode.getTokenAfter(field);
+                const start = tokenBefore ? tokenBefore.range[1] : field.range[0];
+                const end = tokenAfter ? field.range[1] : field.range[1];
+                return fixer.removeRange([start, end]);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+});

package/src/rules/ts-no-unused-protected-readonly.ts

@@ -0,0 +1,151 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule";
+
+function traverseNode(
+  node: TSESTree.Node,
+  callback: (n: TSESTree.Node) => void,
+): void {
+  callback(node);
+  for (const key of Object.keys(node)) {
+    if (key === "parent" || key === "range" || key === "loc") continue;
+    const child = (node as unknown as Record<string, unknown>)[key];
+    if (Array.isArray(child)) {
+      for (const c of child) {
+        if (c != null && typeof c === "object" && "type" in c) {
+          traverseNode(c as TSESTree.Node, callback);
+        }
+      }
+    } else if (child != null && typeof child === "object" && "type" in child) {
+      traverseNode(child as TSESTree.Node, callback);
+    }
+  }
+}
+
+function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Angular `@Component` 내 미사용 `protected readonly` 필드를 감지하는 ESLint 규칙.
+ *
+ * @remarks
+ * `@Component` 데코레이터가 있는 클래스에서 `protected readonly` 필드가
+ * 인라인 템플릿과 클래스 본문 어디에서도 참조되지 않으면 보고합니다.
+ * autofix로 해당 필드를 제거합니다.
+ */
+export default createRule({
+  name: "ts-no-unused-protected-readonly",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused protected readonly fields in Angular components",
+    },
+    fixable: "code",
+    messages: {
+      unusedField: 'Protected readonly field "{{name}}" is not used in class or template.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      "ClassDeclaration, ClassExpression"(
+        classNode: TSESTree.ClassDeclaration | TSESTree.ClassExpression,
+      ) {
+        const componentDecorator = classNode.decorators.find((d) => {
+          if (d.expression.type === AST_NODE_TYPES.CallExpression) {
+            const callee = d.expression.callee;
+            return callee.type === AST_NODE_TYPES.Identifier && callee.name === "Component";
+          }
+          return false;
+        });
+
+        if (componentDecorator == null) return;
+
+        const expr = componentDecorator.expression as TSESTree.CallExpression;
+        const args = expr.arguments;
+        const firstArg = args.at(0);
+        if (firstArg == null || firstArg.type !== AST_NODE_TYPES.ObjectExpression) return;
+
+        const templateProp = firstArg.properties.find(
+          (p): p is TSESTree.Property =>
+            p.type === AST_NODE_TYPES.Property &&
+            p.key.type === AST_NODE_TYPES.Identifier &&
+            p.key.name === "template",
+        );
+
+        if (templateProp == null) return;
+
+        let templateText = "";
+        const templateValue = templateProp.value;
+        if (templateValue.type === AST_NODE_TYPES.TemplateLiteral) {
+          templateText = templateValue.quasis.map((q) => q.value.raw).join("");
+        } else if (
+          templateValue.type === AST_NODE_TYPES.Literal &&
+          typeof templateValue.value === "string"
+        ) {
+          templateText = templateValue.value;
+        }
+
+        if (templateText === "") return;
+
+        const protectedReadonlyFields = classNode.body.body.filter(
+          (node): node is TSESTree.PropertyDefinition =>
+            node.type === AST_NODE_TYPES.PropertyDefinition &&
+            node.accessibility === "protected" &&
+            node.readonly === true &&
+            !node.static &&
+            node.key.type === AST_NODE_TYPES.Identifier,
+        );
+
+        for (const field of protectedReadonlyFields) {
+          const fieldName = (field.key as TSESTree.Identifier).name;
+
+          const identifierPattern = new RegExp(
+            `(?<![a-zA-Z0-9_$])${escapeRegExp(fieldName)}(?![a-zA-Z0-9_$])`,
+          );
+          const usedInTemplate = identifierPattern.test(templateText);
+
+          const usedInClass = classNode.body.body.some((member) => {
+            if (member === field) return false;
+            let found = false;
+            traverseNode(member, (node) => {
+              if (node.type === AST_NODE_TYPES.Identifier && node.name === fieldName) {
+                found = true;
+              }
+            });
+            return found;
+          });
+
+          if (!usedInTemplate && !usedInClass) {
+            context.report({
+              node: field,
+              messageId: "unusedField",
+              data: { name: fieldName },
+              fix(fixer) {
+                let start = field.range[0];
+                let end = field.range[1];
+
+                const textBefore = sourceCode.text.slice(0, start);
+                const leadingMatch = textBefore.match(/\n[ \t]*$/);
+                if (leadingMatch) {
+                  start -= leadingMatch[0].length - 1;
+                }
+
+                const afterText = sourceCode.text.slice(end);
+                const trailingMatch = afterText.match(/^;?[ \t]*\r?\n/);
+                if (trailingMatch) {
+                  end += trailingMatch[0].length;
+                }
+
+                return fixer.removeRange([start, end]);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+});