@simplysm/eslint-plugin 12.15.68 → 12.15.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/eslint-plugin",
-  "version": "12.15.68",
+  "version": "12.15.70",
   "description": "심플리즘 패키지 - ESLINT 플러그인",
   "author": "김석래",
   "repository": {
@@ -19,6 +19,7 @@
     "eslint": "^9.39.1",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-unused-imports": "^4.3.0",
     "globals": "^16.5.0",
     "typescript": "~5.8.3",
     "typescript-eslint": "^8.49.0"

package/src/configs/root.js

@@ -3,6 +3,7 @@ import tseslint from "typescript-eslint";
 import plugin from "../plugin.js";
 import ngeslint from "angular-eslint";
 import importPlugin from "eslint-plugin-import";
+import unusedImportsPlugin from "eslint-plugin-unused-imports";
 
 export default [
   {
@@ -24,6 +25,7 @@ export default [
     plugins: {
       "import": importPlugin,
       "@simplysm": plugin,
+      "unused-imports": unusedImportsPlugin,
     },
     rules: {
       // 기본
@@ -47,9 +49,21 @@ export default [
       "no-shadow": ["error"],
       "no-duplicate-imports": ["error"],
       "no-unused-expressions": ["error"],
-      "no-unused-vars": ["error"],
+      // "no-unused-vars": ["error"],
       "no-undef": ["error"],
 
+      // unused
+      "unused-imports/no-unused-imports": "error",
+      "unused-imports/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          varsIgnorePattern: "^_",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+        },
+      ],
+
       // import
       "import/no-extraneous-dependencies": [
         "error",
@@ -76,6 +90,7 @@ export default [
       "@simplysm": plugin,
       "@angular-eslint": ngeslint.tsPlugin,
       "import": importPlugin,
+      "unused-imports": unusedImportsPlugin,
     },
     /*settings: {
       "import/resolver": {
@@ -126,7 +141,7 @@ export default [
       "@typescript-eslint/prefer-return-this-type": ["error"],
       "@typescript-eslint/typedef": ["error"],
       "@typescript-eslint/no-unused-expressions": ["error"],
-      "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
+      // "@typescript-eslint/no-unused-vars": ["error", { args: "none" }],
       "@typescript-eslint/strict-boolean-expressions": [
         "error",
         {
@@ -218,6 +233,20 @@ export default [
       "@simplysm/ts-no-throw-not-implement-error": ["warn"],
       "@simplysm/no-subpath-imports-from-simplysm": ["error"],
       "@simplysm/no-hard-private": ["error"],
+      "@simplysm/ts-no-unused-injects": ["error"],
+      "@simplysm/ts-no-unused-protected-readonly": ["error"],
+
+      // unused
+      "unused-imports/no-unused-imports": ["error"],
+      "unused-imports/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          varsIgnorePattern: "^_",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+        },
+      ],
 
       // -- 아래 적용 검토가 필요한것
       "import/no-extraneous-dependencies": [

package/src/plugin.js

@@ -5,6 +5,8 @@ import tsNoBufferInTypedArrayContext from "./rules/ts-no-buffer-in-typedarray-co
 import noSubpathImportsFromSimplysm from "./rules/no-subpath-imports-from-simplysm.js";
 import ngTemplateSdRequireBindingAttrs from "./rules/ng-template-sd-require-binding-attrs.js";
 import noHardPrivate from "./rules/no-hard-private.js";
+import tsNoUnusedInjects from "./rules/ts-no-unused-injects.js";
+import tsNoUnusedProtectedReadonly from "./rules/ts-no-unused-protected-readonly.js";
 
 export default {
   rules: {
@@ -15,5 +17,7 @@ export default {
     "no-subpath-imports-from-simplysm": noSubpathImportsFromSimplysm,
     "ng-template-sd-require-binding-attrs": ngTemplateSdRequireBindingAttrs,
     "no-hard-private": noHardPrivate,
+    "ts-no-unused-injects": tsNoUnusedInjects,
+    "ts-no-unused-protected-readonly": tsNoUnusedProtectedReadonly,
   },
 };

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

@@ -0,0 +1,81 @@
+// packages/eslint-plugin/src/rules/ts-no-unused-injects.js
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused Angular inject() fields",
+    },
+    fixable: "code",
+    messages: {
+      unusedInject: 'inject() field "{{name}}" is never used.',
+    },
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ClassBody(classBody) {
+        // inject() 호출로 초기화된 필드 수집
+        const injectFields = classBody.body.filter(
+          (node) =>
+            node.type === "PropertyDefinition" &&
+            node.value?.type === "CallExpression" &&
+            node.value.callee?.name === "inject" &&
+            node.key?.type === "Identifier"
+        );
+
+        for (const field of injectFields) {
+          const fieldName = field.key.name;
+
+          // 클래스 내 모든 Identifier 중 해당 이름 참조 찾기
+          const allIdentifiers = [];
+          traverseNode(classBody, (node) => {
+            if (node.type === "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]);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+// 간단한 AST 순회 헬퍼
+function traverseNode(node, callback) {
+  if (!node || typeof node !== "object") return;
+
+  callback(node);
+
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      child.forEach((c) => traverseNode(c, callback));
+    } else if (child && typeof child === "object" && child.type) {
+      traverseNode(child, callback);
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+export default {
+  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: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ClassDeclaration(classNode) {
+        // @Component 데코레이터 찾기
+        const componentDecorator = classNode.decorators?.find(
+          (d) =>
+            d.expression?.type === "CallExpression" && d.expression.callee?.name === "Component",
+        );
+
+        if (!componentDecorator) return;
+
+        // template 문자열 추출
+        const decoratorArg = componentDecorator.expression.arguments?.[0];
+        if (decoratorArg?.type !== "ObjectExpression") return;
+
+        const templateProp = decoratorArg.properties.find((p) => p.key?.name === "template");
+        if (!templateProp) return;
+
+        const templateValue = templateProp.value;
+        let templateText = "";
+
+        if (templateValue.type === "TemplateLiteral") {
+          templateText = templateValue.quasis.map((q) => q.value.raw).join("");
+        } else if (templateValue.type === "Literal") {
+          templateText = String(templateValue.value);
+        }
+
+        if (!templateText) return;
+
+        // protected readonly 필드 수집
+        const protectedReadonlyFields = classNode.body.body.filter(
+          (node) =>
+            node.type === "PropertyDefinition" &&
+            node.accessibility === "protected" &&
+            node.readonly === true &&
+            !node.static &&
+            node.key?.type === "Identifier",
+        );
+
+        for (const field of protectedReadonlyFields) {
+          const fieldName = field.key.name;
+
+          // 템플릿에서 사용 여부 (바인딩 컨텍스트)
+          const usedInTemplate =
+            templateText.includes(fieldName) && new RegExp(`\\b${fieldName}\\b`).test(templateText);
+
+          // 클래스 내 다른 곳에서 참조 여부
+          const allIdentifiers = [];
+          traverseNode(classNode.body, (node) => {
+            if (node.type === "Identifier" && node.name === fieldName) {
+              allIdentifiers.push(node);
+            }
+          });
+
+          const usedInClass = allIdentifiers.some((id) => id !== field.key);
+
+          if (!usedInTemplate && !usedInClass) {
+            context.report({
+              node: field,
+              messageId: "unusedField",
+              data: { name: fieldName },
+              fix(fixer) {
+                const tokenBefore = sourceCode.getTokenBefore(field);
+                const start = tokenBefore ? tokenBefore.range[1] : field.range[0];
+                return fixer.removeRange([start, field.range[1]]);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+function traverseNode(node, callback) {
+  if (!node || typeof node !== "object") return;
+  callback(node);
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      child.forEach((c) => traverseNode(c, callback));
+    } else if (child && typeof child === "object" && child.type) {
+      traverseNode(child, callback);
+    }
+  }
+}