@simplysm/eslint-plugin 12.9.17 → 12.9.19

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

@@ -8,21 +8,22 @@ export default {
       description: "'NotImplementError' 사용 경고",
     },
     schema: [],
+    messages: {
+      noThrowNotImplementError: "{{text}}",
+    },
   },
-  create: (context) => {
+  defaultOptions: [],
+  create(context) {
     const parserServices = getParserServices(context);
-    const program = parserServices.program;
-    const checker = program.getTypeChecker();
+    const checker = parserServices.program.getTypeChecker();
 
-    function tryGetThrowArgumentType(node) {
+    const tryGetThrowArgumentType = (node) => {
       switch (node.type) {
         case AST_NODE_TYPES.Identifier:
         case AST_NODE_TYPES.CallExpression:
         case AST_NODE_TYPES.NewExpression:
-        case AST_NODE_TYPES.MemberExpression: {
-          const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-          return checker.getTypeAtLocation(tsNode);
-        }
+        case AST_NODE_TYPES.MemberExpression:
+          return checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node));
 
         case AST_NODE_TYPES.AssignmentExpression:
           return tryGetThrowArgumentType(node.right);
@@ -43,28 +44,39 @@ export default {
         default:
           return undefined;
       }
-    }
+    };
 
-    function checkThrowArgument(node) {
-      if (node.type === AST_NODE_TYPES.AwaitExpression || node.type === AST_NODE_TYPES.YieldExpression) {
+    const checkThrowArgument = (node) => {
+      if (
+        node.type === AST_NODE_TYPES.AwaitExpression ||
+        node.type === AST_NODE_TYPES.YieldExpression
+      ) {
         return;
       }
 
       const type = tryGetThrowArgumentType(node);
-      if (type && type.getSymbol() && type.getSymbol().getName() === "NotImplementError") {
+      if (type?.getSymbol()?.getName() === "NotImplementError") {
+        let msg;
+
+        if (
+          node.type === AST_NODE_TYPES.NewExpression &&
+          node.arguments?.[0]?.type === AST_NODE_TYPES.Literal
+        ) {
+          msg = String(node.arguments[0].value ?? "");
+        }
+
         context.report({
-          node: node,
-          message: node["arguments"]["value"] || "구현되어있지 않습니다", //"'NotImplementError'를 'throw'하고 있습니다."
+          node,
+          messageId: "noThrowNotImplementError",
+          data: { text: msg ?? "구현되어있지 않습니다" },
         });
       }
-    }
+    };
 
     return {
       ThrowStatement(node) {
-        if (node.argument) {
-          checkThrowArgument(node.argument);
-        }
+        checkThrowArgument(node.argument);
       },
     };
   },
-};
+};

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

@@ -1,6 +1,6 @@
 import { RuleTester } from 'eslint';
-import rule from '../src/rules/ng-template-no-todo-comments';
-import { describe, expect, it } from "vitest";
+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 규칙 테스트', () => {
@@ -19,50 +19,50 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
   // ESLint 9 플랫 설정 형식 사용
   const ruleTester = new RuleTester({
     languageOptions: {
-      parser: templateParser
-    }
+      parser: templateParser,
+    },
   });
 
   // 기본 템플릿 테스트
   describe('기본 템플릿 테스트', () => {
     // 유효한 템플릿 테스트 (규칙 위반 없음)
-    it('정상적인 HTML 템플릿은 경고가 없어야 함', () => {
+    describe('정상적인 HTML 템플릿은 경고가 없어야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [
           {
             code: createComponentWithTemplate('<div>정상적인 HTML 템플릿</div>'),
-            filename: 'test.component.ts'
-          }
+            filename: 'test.component.ts',
+          },
         ],
-        invalid: []
+        invalid: [],
       });
     });
 
-    it('일반 주석은 경고가 없어야 함', () => {
+    describe('일반 주석은 경고가 없어야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [
           {
             code: createComponentWithTemplate('<!-- 일반 주석 -->'),
-            filename: 'test.component.ts'
-          }
+            filename: 'test.component.ts',
+          },
         ],
-        invalid: []
+        invalid: [],
       });
     });
 
-    it('NOTE 주석은 경고가 없어야 함', () => {
+    describe('NOTE 주석은 경고가 없어야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [
           {
             code: createComponentWithTemplate('<!-- NOTE: 이것은 메모입니다 -->'),
-            filename: 'test.component.ts'
-          }
+            filename: 'test.component.ts',
+          },
         ],
-        invalid: []
+        invalid: [],
       });
     });
 
-    it('여러 줄의 일반 주석은 경고가 없어야 함', () => {
+    describe('여러 줄의 일반 주석은 경고가 없어야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [
           {
@@ -70,30 +70,29 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               <!-- 여러 줄에 걸친 
               일반 주석입니다 -->
             </div>`),
-            filename: 'test.component.ts'
-          }
+            filename: 'test.component.ts',
+          },
         ],
-        invalid: []
+        invalid: [],
       });
     });
   });
 
-  // TODO 주석 테스트
   describe('TODO 주석 테스트', () => {
-    it('단일 TODO 주석은 경고가 발생해야 함', () => {
+    describe('단일 TODO 주석은 경고가 발생해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
           {
             code: createComponentWithTemplate('<!-- TODO: 이 기능 구현 필요 -->'),
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
 
-    it('요소 내부의 TODO 주석은 경고가 발생해야 함', () => {
+    describe('요소 내부의 TODO 주석은 경고가 발생해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -103,13 +102,13 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               <span>임시 내용</span>
             </div>`),
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
 
-    it('주석 텍스트 안에 TODO 키워드가 있으면 경고가 발생해야 함', () => {
+    describe('주석 텍스트 안에 TODO 키워드가 있으면 경고가 발생해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -118,13 +117,13 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               <!-- 이 부분은 TODO: 수정이 필요합니다 -->
             </div>`),
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
 
-    it('여러 줄 주석 내의 TODO 키워드도 감지해야 함', () => {
+    describe('여러 줄 주석 내의 TODO 키워드도 감지해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -137,13 +136,13 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               -->
             </div>`),
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
 
-    it('여러 개의 TODO 주석은 각각 감지되어야 함', () => {
+    describe('여러 개의 TODO 주석은 각각 감지되어야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -154,17 +153,17 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
             filename: 'test.component.ts',
             errors: [
               { messageId: 'noTodo' },
-              { messageId: 'noTodo' }
-            ]
-          }
-        ]
+              { messageId: 'noTodo' },
+            ],
+          },
+        ],
       });
     });
   });
 
   // ng-template 지시자 테스트
   describe('ng-template 지시자 테스트', () => {
-    it('ng-template 안의 TODO 주석을 감지해야 함', () => {
+    describe('ng-template 안의 TODO 주석을 감지해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -180,13 +179,13 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               export class TestComponent {}
             `,
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
 
-    it('ng-template 지시자가 있는 경우에도 정상 작동해야 함', () => {
+    describe('ng-template 지시자가 있는 경우에도 정상 작동해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [
           {
@@ -205,14 +204,14 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               })
               export class TestComponent {}
             `,
-            filename: 'test.component.ts'
-          }
+            filename: 'test.component.ts',
+          },
         ],
-        invalid: []
+        invalid: [],
       });
     });
 
-    it('ng-template 지시자가 있는 경우 TODO 주석을 감지해야 함', () => {
+    describe('ng-template 지시자가 있는 경우 TODO 주석을 감지해야 함', () => {
       ruleTester.run('ng-template-no-todo-comments', rule, {
         valid: [],
         invalid: [
@@ -233,16 +232,16 @@ describe('ng-template-no-todo-comments 규칙 테스트', () => {
               export class TestComponent {}
             `,
             filename: 'test.component.ts',
-            errors: [{ messageId: 'noTodo' }]
-          }
-        ]
+            errors: [{ messageId: 'noTodo' }],
+          },
+        ],
       });
     });
   });
 
   // 정규식 테스트
   describe('정규식 패턴 테스트', () => {
-    it('정규식이 올바르게 TODO 주석을 감지해야 함', () => {
+    describe('정규식이 올바르게 TODO 주석을 감지해야 함', () => {
       const testHtml = `
         <!-- 일반 주석 -->
         <!-- TODO: 할 일 항목 -->

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

@@ -0,0 +1,213 @@
+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;
+RuleTester.it = it;
+RuleTester.itOnly = it.only;
+RuleTester.describe = describe;
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      projectService: {
+        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, {
+        valid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              const arr = new Uint8Array(buf);
+            `,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe('TypedArray를 반환할 때 Buffer를 변환해서 사용하는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              function get(): Uint8Array {
+                return new Uint8Array(buf);
+              }
+            `,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe('TypedArray를 받는 함수에 Buffer가 아닌 TypedArray 인스턴스를 넘기는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              function process(data: Uint8Array) {}
+              process(new Uint8Array(buf));
+            `,
+          },
+        ],
+        invalid: [],
+      });
+    });
+  });
+
+  describe('오류가 발생해야 하는 코드들 (invalid)', () => {
+    describe('Buffer를 TypedArray 타입 변수에 직접 할당하는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              const arr: Uint8Array = buf;
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Uint8Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('Buffer를 TypedArray를 기대하는 함수 인자에 직접 전달하는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              function process(data: Float32Array) {}
+              process(buf);
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Float32Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('Buffer를 TypedArray를 반환해야 하는 함수에서 직접 반환하는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              function give(): Int16Array {
+                return buf;
+              }
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Int16Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('TypedArray 배열에 Buffer를 직접 넣는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              const arr: Uint8Array[] = [buf];
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Uint8Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('객체 속성에 TypedArray를 기대하는데 Buffer를 넣는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              const obj: { x: Int32Array } = { x: buf };
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Int32Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('조건부 표현식에서 Buffer가 TypedArray로 기대되는 경우', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `
+              const buf = Buffer.from('abc');
+              const x: Uint8Array = Math.random() > 0.5 ? buf : new Uint8Array();
+            `,
+            errors: [
+              {
+                messageId: 'directBuffer',
+                data: { expected: 'Uint8Array' },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe('Buffer 사용이 허용되어야 하는 Buffer.정적메서드 호출', () => {
+      ruleTester.run('ts-no-buffer-in-typedarray-context', rule, {
+        valid: [
+          {
+            code: `
+            const list: Buffer[] = [Buffer.from("a"), Buffer.from("b")];
+            Buffer.concat(list); // 허용
+          `,
+          },
+          {
+            code: `
+            const buf = Buffer.from("a");
+            Buffer.concat([buf]); // 허용
+          `,
+          },
+        ],
+        invalid: [],
+      });
+    });
+  });
+});