@simplysm/eslint-plugin 12.16.24 → 12.16.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/eslint-plugin",
-  "version": "12.16.24",
+  "version": "12.16.29",
   "description": "심플리즘 패키지 - ESLINT 플러그인",
   "author": "김석래",
   "repository": {
@@ -13,18 +13,18 @@
   "main": "src/index.js",
   "dependencies": {
     "@angular-eslint/utils": "^20.7.0",
-    "@eslint/compat": "^2.0.0",
-    "@typescript-eslint/utils": "^8.50.0",
+    "@eslint/compat": "^2.0.3",
+    "@typescript-eslint/utils": "^8.57.0",
     "angular-eslint": "^20.7.0",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.4",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-unused-imports": "^4.3.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
     "globals": "^16.5.0",
     "typescript": "~5.8.3",
-    "typescript-eslint": "^8.50.0"
+    "typescript-eslint": "^8.57.0"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "^8.50.0"
+    "@typescript-eslint/rule-tester": "^8.57.0"
   }
 }

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

@@ -22,9 +22,7 @@ export default {
 
       const start = match.index;
       const end = start + match[0].length;
-      const content = commentContent
-        .slice(todoIndex + 5)
-        .trim();
+      const content = commentContent.slice(todoIndex + 5).trim();
 
       const loc = context.getSourceCode().getLocFromIndex(start);
       const endLoc = context.getSourceCode().getLocFromIndex(end);
@@ -38,4 +36,4 @@ export default {
 
     return {};
   },
-};
+};

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

@@ -63,4 +63,4 @@ export default {
       },
     };
   },
-};
+};

package/src/rules/ts-no-buffer-in-typedarray-context.js

@@ -1,22 +1,29 @@
 import ts from "typescript";
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { ESLintUtils } from "@typescript-eslint/utils";
 
 const TYPED_ARRAY_NAMES = new Set([
-  'Uint8Array', 'Uint8ClampedArray',
-  'Int8Array', 'Uint16Array', 'Int16Array',
-  'Uint32Array', 'Int32Array',
-  'Float32Array', 'Float64Array',
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
 ]);
 
 export default {
   meta: {
-    type: 'problem',
+    type: "problem",
     docs: {
-      description: 'Disallow Buffer being used directly in TypedArray contexts. Use new TypedArray(buffer) instead.',
-      recommended: 'error',
+      description:
+        "Disallow Buffer being used directly in TypedArray contexts. Use new TypedArray(buffer) instead.",
+      recommended: "error",
     },
     messages: {
-      directBuffer: 'Do not use Buffer directly where {{expected}} is expected. Use new {{expected}}(buffer) instead.',
+      directBuffer:
+        "Do not use Buffer directly where {{expected}} is expected. Use new {{expected}}(buffer) instead.",
     },
     schema: [],
   },
@@ -39,7 +46,7 @@ export default {
     }
 
     function isBuffer(type) {
-      return getTypeName(type) === 'Buffer';
+      return getTypeName(type) === "Buffer";
     }
 
     function isTypedArray(type) {
@@ -57,7 +64,7 @@ export default {
           const expr = current.expression;
           if (
             expr.expression.kind === ts.SyntaxKind.Identifier &&
-            expr.expression.escapedText === 'Buffer'
+            expr.expression.escapedText === "Buffer"
           ) {
             return true;
           }
@@ -79,15 +86,15 @@ export default {
 
       context.report({
         node,
-        messageId: 'directBuffer',
+        messageId: "directBuffer",
         data: {
-          expected: getTypeName(expectedType) || 'TypedArray',
+          expected: getTypeName(expectedType) || "TypedArray",
         },
       });
     }
 
     function checkTypedAssignment(lhsNode, rhsNode) {
-      if (lhsNode.type !== 'Identifier') return;
+      if (lhsNode.type !== "Identifier") return;
 
       const lhsTsNode = parserServices.esTreeNodeToTSNodeMap.get(lhsNode);
       const expectedType = getCachedType(lhsTsNode);
@@ -140,8 +147,8 @@ export default {
       },
 
       ArrayExpression(node) {
-        node.elements.forEach(el => {
-          if (el && el.type !== 'SpreadElement') {
+        node.elements.forEach((el) => {
+          if (el && el.type !== "SpreadElement") {
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(el);
             const contextualType = checker.getContextualType(tsNode);
             if (contextualType) {

package/src/rules/ts-no-exported-types.js

@@ -7,7 +7,7 @@ export default {
     docs: {
       description:
         "지정된 타입이 export API나 public 클래스 멤버에서 노출되는 것을 금지하고, 대체 타입을 안내합니다.",
-      recommended: 'error',
+      recommended: "error",
     },
     schema: [
       {
@@ -40,11 +40,13 @@ export default {
 
   create(context) {
     const optTypes = context.options[0].types;
-    const optTypeMap = new Map(optTypes.map(t => [
-      t.ban,
-      { safe: t.safe ?? undefined, ignoreInGeneric: t.ignoreInGeneric ?? false },
-    ]));
-    const bannedTypeNames = new Set(optTypes.map(t => t.ban));
+    const optTypeMap = new Map(
+      optTypes.map((t) => [
+        t.ban,
+        { safe: t.safe ?? undefined, ignoreInGeneric: t.ignoreInGeneric ?? false },
+      ]),
+    );
+    const bannedTypeNames = new Set(optTypes.map((t) => t.ban));
 
     const parserServices = ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
@@ -71,11 +73,12 @@ export default {
           return { ban: name, safe: entry.safe };
         }
 
-        const typeArgs = ("aliasTypeArguments" in t && Array.isArray(t.aliasTypeArguments))
-          ? t.aliasTypeArguments
-          : (t.flags & ts.TypeFlags.Object && t.objectFlags & ts.ObjectFlags.Reference)
-            ? checker.getTypeArguments(t)
-            : [];
+        const typeArgs =
+          "aliasTypeArguments" in t && Array.isArray(t.aliasTypeArguments)
+            ? t.aliasTypeArguments
+            : t.flags & ts.TypeFlags.Object && t.objectFlags & ts.ObjectFlags.Reference
+              ? checker.getTypeArguments(t)
+              : [];
 
         for (const arg of typeArgs) {
           const match = visit(arg);
@@ -120,8 +123,7 @@ export default {
     return {
       FunctionDeclaration(node) {
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-        const isExported =
-          (ts.getCombinedModifierFlags(tsNode) & ts.ModifierFlags.Export) !== 0;
+        const isExported = (ts.getCombinedModifierFlags(tsNode) & ts.ModifierFlags.Export) !== 0;
         if (!isExported) return;
 
         const signature = checker.getSignatureFromDeclaration(tsNode);
@@ -137,9 +139,7 @@ export default {
 
       MethodDefinition(node) {
         const isConstructor = node.kind === "constructor";
-        const isPublic =
-          node.accessibility !== "private" &&
-          node.accessibility !== "protected";
+        const isPublic = node.accessibility !== "private" && node.accessibility !== "protected";
         if (!isConstructor && !isPublic) return;
 
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.value);
@@ -157,8 +157,7 @@ export default {
       },
 
       PropertyDefinition(node) {
-        const isPublic =
-          node.accessibility !== "private" && node.accessibility !== "protected";
+        const isPublic = node.accessibility !== "private" && node.accessibility !== "protected";
         if (!isPublic) return;
 
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
@@ -184,8 +183,7 @@ export default {
             node.id.typeAnnotation.typeAnnotation,
           );
           type = checker.getTypeFromTypeNode(tsType);
-        }
-        else if (node.init) {
+        } else if (node.init) {
           const tsInit = parserServices.esTreeNodeToTSNodeMap.get(node.init);
           type = getCachedType(tsInit);
         }

package/src/rules/ts-no-throw-not-implement-error.js

@@ -79,4 +79,4 @@ export default {
       },
     };
   },
-};
+};

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

@@ -23,7 +23,7 @@ export default {
             node.type === "PropertyDefinition" &&
             node.value?.type === "CallExpression" &&
             node.value.callee?.name === "inject" &&
-            node.key?.type === "Identifier"
+            node.key?.type === "Identifier",
         );
 
         for (const field of injectFields) {

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

@@ -31,7 +31,8 @@ export default {
         if (!args?.[0] || args[0].type !== "ObjectExpression") return;
 
         const templateProp = args[0].properties.find(
-          (p) => p.type === "Property" && p.key?.type === "Identifier" && p.key?.name === "template"
+          (p) =>
+            p.type === "Property" && p.key?.type === "Identifier" && p.key?.name === "template",
         );
 
         if (!templateProp) return;
@@ -54,7 +55,7 @@ export default {
             node.accessibility === "protected" &&
             node.readonly === true &&
             !node.static &&
-            node.key?.type === "Identifier"
+            node.key?.type === "Identifier",
         );
 
         for (const field of protectedReadonlyFields) {
@@ -63,7 +64,7 @@ export default {
           // 템플릿에서 사용 여부
           // \b는 $로 시작하는 identifier에서 동작 안 함 → lookahead/lookbehind 사용
           const identifierPattern = new RegExp(
-            `(?<![a-zA-Z0-9_$])${escapeRegExp(fieldName)}(?![a-zA-Z0-9_$])`
+            `(?<![a-zA-Z0-9_$])${escapeRegExp(fieldName)}(?![a-zA-Z0-9_$])`,
           );
           const usedInTemplate = identifierPattern.test(templateText);
 

package/tests/ng-template-no-todo-comments.spec.js

@@ -1,9 +1,9 @@
-import { RuleTester } from 'eslint';
-import rule from '../src/rules/ng-template-no-todo-comments.js';
+import { RuleTester } from "eslint";
+import rule from "../src/rules/ng-template-no-todo-comments.js";
 import { describe, expect } from "vitest";
 import { templateParser } from "angular-eslint";
 
-describe('ng-template-no-todo-comments 규칙 테스트', () => {
+describe("ng-template-no-todo-comments 규칙 테스트", () => {
   // 인라인 템플릿을 가진 Angular 컴포넌트 생성을 위한 헬퍼 함수
   const createComponentWithTemplate = (template) => `
     import { Component } from '@angular/core';
@@ -24,53 +24,53 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
   });
 
   // 기본 템플릿 테스트
-  describe('기본 템플릿 테스트', () => {
+  describe("기본 템플릿 테스트", () => {
     // 유효한 템플릿 테스트 (규칙 위반 없음)
-    describe('정상적인 HTML 템플릿은 경고가 없어야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("정상적인 HTML 템플릿은 경고가 없어야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [
           {
-            code: createComponentWithTemplate('<div>정상적인 HTML 템플릿</div>'),
-            filename: 'test.component.ts',
+            code: createComponentWithTemplate("<div>정상적인 HTML 템플릿</div>"),
+            filename: "test.component.ts",
           },
         ],
         invalid: [],
       });
     });
 
-    describe('일반 주석은 경고가 없어야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("일반 주석은 경고가 없어야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [
           {
-            code: createComponentWithTemplate('<!-- 일반 주석 -->'),
-            filename: 'test.component.ts',
+            code: createComponentWithTemplate("<!-- 일반 주석 -->"),
+            filename: "test.component.ts",
           },
         ],
         invalid: [],
       });
     });
 
-    describe('NOTE 주석은 경고가 없어야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("NOTE 주석은 경고가 없어야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [
           {
-            code: createComponentWithTemplate('<!-- NOTE: 이것은 메모입니다 -->'),
-            filename: 'test.component.ts',
+            code: createComponentWithTemplate("<!-- NOTE: 이것은 메모입니다 -->"),
+            filename: "test.component.ts",
           },
         ],
         invalid: [],
       });
     });
 
-    describe('여러 줄의 일반 주석은 경고가 없어야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("여러 줄의 일반 주석은 경고가 없어야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [
           {
             code: createComponentWithTemplate(`<div>
               <!-- 여러 줄에 걸친 
               일반 주석입니다 -->
             </div>`),
-            filename: 'test.component.ts',
+            filename: "test.component.ts",
           },
         ],
         invalid: [],
@@ -78,22 +78,22 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
     });
   });
 
-  describe('TODO 주석 테스트', () => {
-    describe('단일 TODO 주석은 경고가 발생해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+  describe("TODO 주석 테스트", () => {
+    describe("단일 TODO 주석은 경고가 발생해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
-            code: createComponentWithTemplate('<!-- TODO: 이 기능 구현 필요 -->'),
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            code: createComponentWithTemplate("<!-- TODO: 이 기능 구현 필요 -->"),
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
     });
 
-    describe('요소 내부의 TODO 주석은 경고가 발생해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("요소 내부의 TODO 주석은 경고가 발생해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
@@ -101,30 +101,30 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               <!-- TODO: 여기에 폼 추가하기 -->
               <span>임시 내용</span>
             </div>`),
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
     });
 
-    describe('주석 텍스트 안에 TODO 키워드가 있으면 경고가 발생해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("주석 텍스트 안에 TODO 키워드가 있으면 경고가 발생해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
             code: createComponentWithTemplate(`<div>
               <!-- 이 부분은 TODO: 수정이 필요합니다 -->
             </div>`),
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
     });
 
-    describe('여러 줄 주석 내의 TODO 키워드도 감지해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("여러 줄 주석 내의 TODO 키워드도 감지해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
@@ -135,26 +135,23 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
                 가 포함된 케이스
               -->
             </div>`),
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
     });
 
-    describe('여러 개의 TODO 주석은 각각 감지되어야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("여러 개의 TODO 주석은 각각 감지되어야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
             code: createComponentWithTemplate(`<!-- TODO: 첫 번째 할 일 -->
             <div>내용</div>
             <!-- TODO: 두 번째 할 일 -->`),
-            filename: 'test.component.ts',
-            errors: [
-              { messageId: 'noTodo' },
-              { messageId: 'noTodo' },
-            ],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }, { messageId: "noTodo" }],
           },
         ],
       });
@@ -162,9 +159,9 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
   });
 
   // ng-template 지시자 테스트
-  describe('ng-template 지시자 테스트', () => {
-    describe('ng-template 안의 TODO 주석을 감지해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+  describe("ng-template 지시자 테스트", () => {
+    describe("ng-template 안의 TODO 주석을 감지해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
@@ -178,15 +175,15 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               })
               export class TestComponent {}
             `,
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
     });
 
-    describe('ng-template 지시자가 있는 경우에도 정상 작동해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("ng-template 지시자가 있는 경우에도 정상 작동해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [
           {
             code: `
@@ -204,15 +201,15 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               })
               export class TestComponent {}
             `,
-            filename: 'test.component.ts',
+            filename: "test.component.ts",
           },
         ],
         invalid: [],
       });
     });
 
-    describe('ng-template 지시자가 있는 경우 TODO 주석을 감지해야 함', () => {
-      ruleTester.run('ng-template-no-todo-comments', rule, {
+    describe("ng-template 지시자가 있는 경우 TODO 주석을 감지해야 함", () => {
+      ruleTester.run("ng-template-no-todo-comments", rule, {
         valid: [],
         invalid: [
           {
@@ -231,8 +228,8 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               })
               export class TestComponent {}
             `,
-            filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }],
+            filename: "test.component.ts",
+            errors: [{ messageId: "noTodo" }],
           },
         ],
       });
@@ -240,8 +237,8 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
   });
 
   // 정규식 테스트
-  describe('정규식 패턴 테스트', () => {
-    describe('정규식이 올바르게 TODO 주석을 감지해야 함', () => {
+  describe("정규식 패턴 테스트", () => {
+    describe("정규식이 올바르게 TODO 주석을 감지해야 함", () => {
       const testHtml = `
         <!-- 일반 주석 -->
         <!-- TODO: 할 일 항목 -->
@@ -254,7 +251,7 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
       const matches = [...testHtml.matchAll(commentRegex)];
 
       // 매칭된 주석 중 'TODO:'가 포함된 주석 수 확인
-      const todoComments = matches.filter(match => match[0].includes('TODO:'));
+      const todoComments = matches.filter((match) => match[0].includes("TODO:"));
       expect(todoComments.length).toBe(1);
     });
   });

package/tests/ts-no-buffer-in-typedarray-context.spec.js

@@ -1,6 +1,6 @@
-import { afterAll, describe, it } from 'vitest';
-import { RuleTester } from '@typescript-eslint/rule-tester';
-import rule from '../src/rules/ts-no-buffer-in-typedarray-context.js';
+import { afterAll, describe, it } from "vitest";
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../src/rules/ts-no-buffer-in-typedarray-context.js";
 
 // vitest 훅 바인딩
 RuleTester.afterAll = afterAll;
@@ -12,16 +12,16 @@ const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
       projectService: {
-        allowDefaultProject: ['*.ts*'],
+        allowDefaultProject: ["*.ts*"],
       },
     },
   },
 });
 
-describe('ts-no-buffer-in-typedarray-context 규칙', () => {
-  describe('허용되는 코드들 (valid)', () => {
-    describe('Buffer를 new TypedArray(buffer)로 감싸서 사용하는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+describe("ts-no-buffer-in-typedarray-context 규칙", () => {
+  describe("허용되는 코드들 (valid)", () => {
+    describe("Buffer를 new TypedArray(buffer)로 감싸서 사용하는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [
           {
             code: `
@@ -34,8 +34,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('TypedArray를 반환할 때 Buffer를 변환해서 사용하는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("TypedArray를 반환할 때 Buffer를 변환해서 사용하는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [
           {
             code: `
@@ -50,8 +50,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('TypedArray를 받는 함수에 Buffer가 아닌 TypedArray 인스턴스를 넘기는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("TypedArray를 받는 함수에 Buffer가 아닌 TypedArray 인스턴스를 넘기는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [
           {
             code: `
@@ -66,9 +66,9 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
     });
   });
 
-  describe('오류가 발생해야 하는 코드들 (invalid)', () => {
-    describe('Buffer를 TypedArray 타입 변수에 직접 할당하는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+  describe("오류가 발생해야 하는 코드들 (invalid)", () => {
+    describe("Buffer를 TypedArray 타입 변수에 직접 할당하는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -78,8 +78,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Uint8Array' },
+                messageId: "directBuffer",
+                data: { expected: "Uint8Array" },
               },
             ],
           },
@@ -87,8 +87,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('Buffer를 TypedArray를 기대하는 함수 인자에 직접 전달하는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("Buffer를 TypedArray를 기대하는 함수 인자에 직접 전달하는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -99,8 +99,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Float32Array' },
+                messageId: "directBuffer",
+                data: { expected: "Float32Array" },
               },
             ],
           },
@@ -108,8 +108,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('Buffer를 TypedArray를 반환해야 하는 함수에서 직접 반환하는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("Buffer를 TypedArray를 반환해야 하는 함수에서 직접 반환하는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -121,8 +121,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Int16Array' },
+                messageId: "directBuffer",
+                data: { expected: "Int16Array" },
               },
             ],
           },
@@ -130,8 +130,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('TypedArray 배열에 Buffer를 직접 넣는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("TypedArray 배열에 Buffer를 직접 넣는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -141,8 +141,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Uint8Array' },
+                messageId: "directBuffer",
+                data: { expected: "Uint8Array" },
               },
             ],
           },
@@ -150,8 +150,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('객체 속성에 TypedArray를 기대하는데 Buffer를 넣는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("객체 속성에 TypedArray를 기대하는데 Buffer를 넣는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -161,8 +161,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Int32Array' },
+                messageId: "directBuffer",
+                data: { expected: "Int32Array" },
               },
             ],
           },
@@ -170,8 +170,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('조건부 표현식에서 Buffer가 TypedArray로 기대되는 경우', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("조건부 표현식에서 Buffer가 TypedArray로 기대되는 경우", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [],
         invalid: [
           {
@@ -181,8 +181,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
             `,
             errors: [
               {
-                messageId: 'directBuffer',
-                data: { expected: 'Uint8Array' },
+                messageId: "directBuffer",
+                data: { expected: "Uint8Array" },
               },
             ],
           },
@@ -190,8 +190,8 @@ describe('ts-no-buffer-in-typedarray-context 규칙', () => {
       });
     });
 
-    describe('Buffer 사용이 허용되어야 하는 Buffer.정적메서드 호출', () => {
-      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+    describe("Buffer 사용이 허용되어야 하는 Buffer.정적메서드 호출", () => {
+      ruleTester.run("ts-no-buffer-in-typedarray-context", rule, {
         valid: [
           {
             code: `

package/tests/ts-no-exported-types.spec.js

@@ -1,6 +1,6 @@
-import { afterAll, describe, it } from 'vitest';
-import { RuleTester } from '@typescript-eslint/rule-tester';
-import rule from '../src/rules/ts-no-exported-types.js';
+import { afterAll, describe, it } from "vitest";
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../src/rules/ts-no-exported-types.js";
 
 RuleTester.afterAll = afterAll;
 RuleTester.it = it;
@@ -11,31 +11,31 @@ const ruleTester = new RuleTester({
   languageOptions: {
     parserOptions: {
       projectService: {
-        allowDefaultProject: ['*.ts*'],
+        allowDefaultProject: ["*.ts*"],
       },
     },
   },
 });
 
-describe('ts-no-exported-types 규칙', () => {
-  describe('허용되는 코드들 (valid)', () => {
-    describe('제한된 타입을 내부 함수에서만 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+describe("ts-no-exported-types 규칙", () => {
+  describe("허용되는 코드들 (valid)", () => {
+    describe("제한된 타입을 내부 함수에서만 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [
           {
             code: `
               type Internal = string;
               function internalFunc(x: Internal) {}
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
           },
         ],
         invalid: [],
       });
     });
 
-    describe('export 함수가 안전한 타입만 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("export 함수가 안전한 타입만 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [
           {
             code: `
@@ -43,15 +43,15 @@ describe('ts-no-exported-types 규칙', () => {
                 return 1;
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
           },
         ],
         invalid: [],
       });
     });
 
-    describe('제한된 타입을 private 속성으로만 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 private 속성으로만 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [
           {
             code: `
@@ -59,7 +59,7 @@ describe('ts-no-exported-types 규칙', () => {
                 private prop: Foo;
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
           },
         ],
         invalid: [],
@@ -67,9 +67,9 @@ describe('ts-no-exported-types 규칙', () => {
     });
   });
 
-  describe('오류가 발생해야 하는 코드들 (invalid)', () => {
-    describe('제한된 타입을 export 함수의 파라미터로 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+  describe("오류가 발생해야 하는 코드들 (invalid)", () => {
+    describe("제한된 타입을 export 함수의 파라미터로 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -78,11 +78,11 @@ describe('ts-no-exported-types 규칙', () => {
                 return 1;
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Foo', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Foo", safeSuggestion: "" },
               },
             ],
           },
@@ -90,8 +90,8 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('제한된 타입을 반환값으로 사용하는 export 함수', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 반환값으로 사용하는 export 함수", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -100,11 +100,11 @@ describe('ts-no-exported-types 규칙', () => {
                 return {} as Foo;
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Foo', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Foo", safeSuggestion: "" },
               },
             ],
           },
@@ -112,8 +112,8 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('제한된 타입을 public 속성으로 사용하는 export 클래스', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 public 속성으로 사용하는 export 클래스", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -122,11 +122,11 @@ describe('ts-no-exported-types 규칙', () => {
                 public prop: Foo;
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Foo', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Foo", safeSuggestion: "" },
               },
             ],
           },
@@ -134,8 +134,8 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('제한된 타입을 public 메서드의 파라미터로 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 public 메서드의 파라미터로 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -144,11 +144,11 @@ describe('ts-no-exported-types 규칙', () => {
                 method(x: Foo): void {}
               }
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Foo', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Foo", safeSuggestion: "" },
               },
             ],
           },
@@ -156,19 +156,19 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('제한된 타입을 사용하는 export const 선언', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 사용하는 export const 선언", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
             code: `
               export const myValue: Foo = {} as Foo;
             `,
-            options: [{ types: [{ ban: 'Foo' }] }],
+            options: [{ types: [{ ban: "Foo" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Foo', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Foo", safeSuggestion: "" },
               },
             ],
           },
@@ -176,8 +176,8 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('제한된 타입을 생성자의 파라미터로 사용하는 경우', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("제한된 타입을 생성자의 파라미터로 사용하는 경우", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -186,30 +186,30 @@ describe('ts-no-exported-types 규칙', () => {
                 constructor(arg?: Blob | Uint8Array) {}
               }
             `,
-            options: [{ types: [{ ban: 'Uint8Array' }] }],
-            errors: [{ messageId: 'noExportedTypes' }],
+            options: [{ types: [{ ban: "Uint8Array" }] }],
+            errors: [{ messageId: "noExportedTypes" }],
           },
         ],
       });
     });
 
-    describe('유니언 타입 중 하나가 제한된 타입이면 오류 발생해야 함 (파라미터)', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("유니언 타입 중 하나가 제한된 타입이면 오류 발생해야 함 (파라미터)", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
             code: `
               export function readData(x: Uint8Array | string): void {}
             `,
-            options: [{ types: [{ ban: 'Uint8Array' }] }],
-            errors: [{ messageId: 'noExportedTypes' }],
+            options: [{ types: [{ ban: "Uint8Array" }] }],
+            errors: [{ messageId: "noExportedTypes" }],
           },
         ],
       });
     });
 
-    describe('유니언 타입 중 하나가 제한된 타입이면 오류 발생해야 함 (반환값)', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("유니언 타입 중 하나가 제한된 타입이면 오류 발생해야 함 (반환값)", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -218,15 +218,15 @@ describe('ts-no-exported-types 규칙', () => {
                 return new Uint8Array();
               }
             `,
-            options: [{ types: [{ ban: 'Uint8Array' }] }],
-            errors: [{ messageId: 'noExportedTypes' }],
+            options: [{ types: [{ ban: "Uint8Array" }] }],
+            errors: [{ messageId: "noExportedTypes" }],
           },
         ],
       });
     });
 
-    describe('유니언 타입 속성에서도 제한된 타입이면 오류 발생해야 함', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("유니언 타입 속성에서도 제한된 타입이면 오류 발생해야 함", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
@@ -235,11 +235,11 @@ describe('ts-no-exported-types 규칙', () => {
                 public buffer: string | Uint8Array;
               }
             `,
-            options: [{ types: [{ ban: 'Uint8Array' }] }],
+            options: [{ types: [{ ban: "Uint8Array" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Uint8Array', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Uint8Array", safeSuggestion: "" },
               },
             ],
           },
@@ -247,20 +247,20 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('export const 선언에서도 유니언 타입 중 제한된 타입이 있으면 오류', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("export const 선언에서도 유니언 타입 중 제한된 타입이 있으면 오류", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
             code: `
               export const data: Uint8Array | number = new Uint8Array();
             `,
-            options: [{ types: [{ ban: 'Uint8Array', safe: 'Buffer' }] }],
+            options: [{ types: [{ ban: "Uint8Array", safe: "Buffer" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
+                messageId: "noExportedTypes",
                 data: {
-                  typeName: 'Uint8Array',
+                  typeName: "Uint8Array",
                   safeSuggestion: ' 더 안전한 대체 타입 "Buffer"을(를) 사용하세요.',
                 },
               },
@@ -270,19 +270,19 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('Generic 안쪽에도 없어야함', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("Generic 안쪽에도 없어야함", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [],
         invalid: [
           {
             code: `
               export const myValue: Foo<Bar> = {};
             `,
-            options: [{ types: [{ ban: 'Bar' }] }],
+            options: [{ types: [{ ban: "Bar" }] }],
             errors: [
               {
-                messageId: 'noExportedTypes',
-                data: { typeName: 'Bar', safeSuggestion: '' },
+                messageId: "noExportedTypes",
+                data: { typeName: "Bar", safeSuggestion: "" },
               },
             ],
           },
@@ -290,14 +290,14 @@ describe('ts-no-exported-types 규칙', () => {
       });
     });
 
-    describe('Generic 안쪽에 있어도 ignoreInGeneric 이면 허용됨', () => {
-      ruleTester.run('ts-no-exported-types', rule, {
+    describe("Generic 안쪽에 있어도 ignoreInGeneric 이면 허용됨", () => {
+      ruleTester.run("ts-no-exported-types", rule, {
         valid: [
           {
             code: `
           export const myValue: Foo<Bar> = {};
         `,
-            options: [{ types: [{ ban: 'Bar', ignoreInGeneric: true }] }],
+            options: [{ types: [{ ban: "Bar", ignoreInGeneric: true }] }],
           },
         ],
         invalid: [],