@simplysm/eslint-plugin 12.9.16 → 12.9.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/eslint-plugin",
-  "version": "12.9.16",
+  "version": "12.9.18",
   "description": "심플리즘 패키지 - ESLINT 플러그인",
   "author": "김석래",
   "repository": {
@@ -14,14 +14,16 @@
   "dependencies": {
     "@eslint/compat": "^1.2.9",
     "@typescript-eslint/utils": "^8.32.0",
-    "angular-eslint": "^19.3.0",
+    "angular-eslint": "^19.4.0",
     "eslint": "^9.26.0",
+    "eslint-import-resolver-typescript": "^4.3.4",
     "eslint-plugin-import": "^2.31.0",
     "globals": "^16.1.0",
     "typescript": "~5.7.3",
     "typescript-eslint": "^8.32.0"
   },
   "devDependencies": {
+    "@typescript-eslint/rule-tester": "^8.32.0",
     "vitest": "^3.1.3"
   }
 }

package/src/configs/root.js

@@ -27,11 +27,15 @@ export default [
       // 기본
       "no-console": ["warn"],
       "no-warning-comments": ["warn"],
-      'no-restricted-syntax': [
-        'error',
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "PropertyDefinition[key.type='PrivateIdentifier']",
+          message: "Do not use ECMAScript private fields (e.g. #myField); use TypeScript \"private\" instead.",
+        },
         {
-          selector: 'PropertyDefinition[key.type="PrivateIdentifier"]',
-          message: 'Do not use ECMAScript private fields (e.g. #myField); use TypeScript "private" instead.',
+          selector: "MethodDefinition[key.type='PrivateIdentifier']",
+          message: "Do not use ECMAScript private methods (e.g. #myMethod); use TypeScript \"private\" instead.",
         },
       ],
       "eqeqeq": ["error", "always", { "null": "ignore" }],
@@ -56,6 +60,15 @@ export default [
       "@angular-eslint": ngeslint.tsPlugin,
       "import": importPlugin,
     },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          project: [
+            "./tsconfig.base.json",
+          ],
+        },
+      },
+    },
     processor: ngeslint.processInlineTemplates,
     languageOptions: {
       parser: tseslint.parser,
@@ -67,11 +80,15 @@ export default [
       // 기본
       "no-console": ["warn"],
       "no-warning-comments": ["warn"],
-      'no-restricted-syntax': [
-        'error',
+      "no-restricted-syntax": [
+        "error",
         {
-          selector: 'PropertyDefinition[key.type="PrivateIdentifier"]',
-          message: 'Do not use ECMAScript private fields (e.g. #myField); use TypeScript "private" instead.',
+          selector: "PropertyDefinition[key.type='PrivateIdentifier']",
+          message: "Do not use ECMAScript private fields (e.g. #myField); use TypeScript \"private\" instead.",
+        },
+        {
+          selector: "MethodDefinition[key.type='PrivateIdentifier']",
+          message: "Do not use ECMAScript private methods (e.g. #myMethod); use TypeScript \"private\" instead.",
         },
       ],
       "eqeqeq": ["error", "always", { "null": "ignore" }],
@@ -115,12 +132,92 @@ export default [
           // "ignoreTernaryTests": true,
         },
       ],*/
+      "@typescript-eslint/naming-convention": [
+        "error",
+        // (1) private 대문자 필드 → 예외 허용
+        {
+          "selector": "classProperty",
+          "modifiers": ["private"],
+          "format": ["UPPER_CASE"],
+          "leadingUnderscore": "forbid",
+          "filter": {
+            "regex": "^[A-Z0-9_]+$",
+            "match": true
+          }
+        },
 
-      // import
-      "import/no-extraneous-dependencies": ["error"], // 느림
+        // (2) private 필드
+        {
+          "selector": "classProperty",
+          "modifiers": ["private"],
+          "format": ["camelCase"],
+          "leadingUnderscore": "require"
+        },
+        // private 메서드
+        {
+          "selector": "method",
+          "modifiers": ["private"],
+          "format": ["camelCase"],
+          "leadingUnderscore": "require",
+        },
+        // (1) protected readonly 필드 → 예외 허용
+        {
+          "selector": "classProperty",
+          "modifiers": ["protected", "readonly"],
+          "format": null,
+          "leadingUnderscore": "allow"  // 언더스코어도 허용
+        },
+
+        // (2) protected 필드
+        {
+          "selector": "classProperty",
+          "modifiers": ["protected"],
+          "format": ["camelCase"],
+          "leadingUnderscore": "require"
+        },
+        // protected 메서드
+        {
+          "selector": "method",
+          "modifiers": ["protected"],
+          "format": ["camelCase"],
+          "leadingUnderscore": "require",
+        },
+      ],
 
-      // 심플리즘
+      //-- 심플리즘
       "@simplysm/ts-no-throw-not-implement-error": ["warn"],
+
+
+      // -- 아래 룰들은 매우 느림
+      // 라이브러리 작성시, 그때그때 필요할 때만 사용
+
+      // "import/no-extraneous-dependencies": [
+      //   "error",
+      //   {
+      //     "devDependencies": [
+      //       "**/*.spec.ts",
+      //       "**/lib/**",
+      //       "**!/eslint.config.js",
+      //       "**!/simplysm.js",
+      //       "**/vitest.config.js",
+      //     ],
+      //   },
+      // ],
+      // "@simplysm/ts-no-exported-types": [
+      //   "error", {
+      //     types: [
+      //       {
+      //         ban: "Uint8Array",
+      //         safe: "Buffer",
+      //       }, {
+      //         ban: "ArrayBuffer",
+      //         safe: "Buffer",
+      //         ignoreInGeneric: true,
+      //       },
+      //     ],
+      //   },
+      // ],
+      // "@simplysm/ts-no-buffer-in-typedarray-context": ["error"],
     },
   },
   {
@@ -137,4 +234,4 @@ export default [
       // "@angular-eslint/template/use-track-by-function": "error",
     },
   },
-];
+];

package/src/index.js

@@ -1,7 +1,3 @@
 import root from "./configs/root.js";
 
-export default {
-  configs: {
-    root,
-  },
-};
+export default { configs: { root } };

package/src/plugin.js

@@ -1,9 +1,13 @@
 import tsNoThrowNotImplementError from "./rules/ts-no-throw-not-implement-error.js";
 import ngTemplateNoTodoComments from "./rules/ng-template-no-todo-comments.js";
+import tsNoExportedTypes from "./rules/ts-no-exported-types.js";
+import tsNoBufferInTypedArrayContext from "./rules/ts-no-buffer-in-typedarray-context.js";
 
 export default {
   rules: {
     "ts-no-throw-not-implement-error": tsNoThrowNotImplementError,
+    "ts-no-exported-types": tsNoExportedTypes,
+    "ts-no-buffer-in-typedarray-context": tsNoBufferInTypedArrayContext,
     "ng-template-no-todo-comments": ngTemplateNoTodoComments,
   },
-};
+};

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

@@ -2,33 +2,29 @@ export default {
   meta: {
     type: "problem",
     docs: {
-      description: "HTML 템플릿내 TODO 주석을 경고합니다.",
+      description: "HTML 템플릿 내 TODO 주석을 경고합니다.",
     },
     schema: [],
     messages: {
-      noTodo: "Unexpected TODO comment in HTML template: '{{content}}'",
+      noTodo: "{{content}}",
     },
   },
 
   create(context) {
     const source = context.getSourceCode().getText();
-
-    const commentRegex = /<!--[\s\S]*?-->/g;
+    const commentRegex = /<!--([\s\S]*?)-->/g;
     let match;
 
     while ((match = commentRegex.exec(source)) !== null) {
-      const comment = match[0];
-      if (!comment.includes("TODO:")) continue;
+      const commentContent = match[1];
+      const todoIndex = commentContent.indexOf("TODO:");
+      if (todoIndex < 0) continue;
 
       const start = match.index;
-      const end = start + comment.length;
-
-      const contentMatch = comment.match(/<!--([\s\S]*?)-->/);
-      let content = contentMatch ? contentMatch[1].trim() : "";
-      const todoIndex = content.indexOf("TODO:");
-      if (todoIndex !== -1) {
-        content = content.substring(todoIndex + 5).trim();
-      }
+      const end = start + match[0].length;
+      const content = commentContent
+        .slice(todoIndex + 5)
+        .trim();
 
       const loc = context.getSourceCode().getLocFromIndex(start);
       const endLoc = context.getSourceCode().getLocFromIndex(end);
@@ -36,9 +32,7 @@ export default {
       context.report({
         loc: { start: loc, end: endLoc },
         messageId: "noTodo",
-        data: {
-          content: content,
-        },
+        data: { content },
       });
     }
 

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

@@ -0,0 +1,165 @@
+import ts from "typescript";
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+const TYPED_ARRAY_NAMES = new Set([
+  'Uint8Array', 'Uint8ClampedArray',
+  'Int8Array', 'Uint16Array', 'Int16Array',
+  'Uint32Array', 'Int32Array',
+  'Float32Array', 'Float64Array',
+]);
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      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.',
+    },
+    schema: [],
+  },
+
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+    const typeCache = new WeakMap();
+
+    function getCachedType(tsNode) {
+      if (typeCache.has(tsNode)) return typeCache.get(tsNode);
+      const type = checker.getTypeAtLocation(tsNode);
+      typeCache.set(tsNode, type);
+      return type;
+    }
+
+    function getTypeName(type) {
+      const symbol = type.getSymbol();
+      return symbol ? symbol.getName() : undefined;
+    }
+
+    function isBuffer(type) {
+      return getTypeName(type) === 'Buffer';
+    }
+
+    function isTypedArray(type) {
+      const name = getTypeName(type);
+      return name && TYPED_ARRAY_NAMES.has(name);
+    }
+
+    function isInsideBufferStaticCall(tsNode) {
+      let current = tsNode.parent;
+      while (current) {
+        if (
+          current.kind === ts.SyntaxKind.CallExpression &&
+          current.expression.kind === ts.SyntaxKind.PropertyAccessExpression
+        ) {
+          const expr = current.expression;
+          if (
+            expr.expression.kind === ts.SyntaxKind.Identifier &&
+            expr.expression.escapedText === 'Buffer'
+          ) {
+            return true;
+          }
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    function reportIfInvalid(node, expectedType) {
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+      const actualType = getCachedType(tsNode);
+
+      // 예외: Buffer.~~~ 함수 호출 내의 인자는 검사 대상에서 제외
+      if (isInsideBufferStaticCall(tsNode)) return;
+
+      if (!isBuffer(actualType)) return;
+      if (!isTypedArray(expectedType)) return;
+
+      context.report({
+        node,
+        messageId: 'directBuffer',
+        data: {
+          expected: getTypeName(expectedType) || 'TypedArray',
+        },
+      });
+    }
+
+    function checkTypedAssignment(lhsNode, rhsNode) {
+      if (lhsNode.type !== 'Identifier') return;
+
+      const lhsTsNode = parserServices.esTreeNodeToTSNodeMap.get(lhsNode);
+      const expectedType = getCachedType(lhsTsNode);
+
+      reportIfInvalid(rhsNode, expectedType);
+    }
+
+    return {
+      VariableDeclarator(node) {
+        if (node.init && node.id) {
+          checkTypedAssignment(node.id, node.init);
+        }
+      },
+
+      AssignmentExpression(node) {
+        checkTypedAssignment(node.left, node.right);
+      },
+
+      ReturnStatement(node) {
+        if (!node.argument) return;
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.argument);
+        const contextualType = checker.getContextualType(tsNode);
+        if (contextualType) {
+          reportIfInvalid(node.argument, contextualType);
+        }
+      },
+
+      CallExpression(node) {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const signature = checker.getResolvedSignature(tsNode);
+        if (!signature) return;
+
+        const params = signature.getParameters();
+        node.arguments.forEach((arg, index) => {
+          const param = params[index];
+          if (!param) return;
+
+          const paramType = checker.getTypeOfSymbolAtLocation(param, tsNode);
+          reportIfInvalid(arg, paramType);
+        });
+      },
+
+      Property(node) {
+        if (!node.value) return;
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.value);
+        const contextualType = checker.getContextualType(tsNode);
+        if (contextualType) {
+          reportIfInvalid(node.value, contextualType);
+        }
+      },
+
+      ArrayExpression(node) {
+        node.elements.forEach(el => {
+          if (el && el.type !== 'SpreadElement') {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(el);
+            const contextualType = checker.getContextualType(tsNode);
+            if (contextualType) {
+              reportIfInvalid(el, contextualType);
+            }
+          }
+        });
+      },
+
+      ConditionalExpression(node) {
+        const thenTsNode = parserServices.esTreeNodeToTSNodeMap.get(node.consequent);
+        const elseTsNode = parserServices.esTreeNodeToTSNodeMap.get(node.alternate);
+        const thenType = checker.getContextualType(thenTsNode);
+        const elseType = checker.getContextualType(elseTsNode);
+
+        if (thenType) reportIfInvalid(node.consequent, thenType);
+        if (elseType) reportIfInvalid(node.alternate, elseType);
+      },
+    };
+  },
+};

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

@@ -0,0 +1,199 @@
+import ts from "typescript";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "지정된 타입이 export API나 public 클래스 멤버에서 노출되는 것을 금지하고, 대체 타입을 안내합니다.",
+      recommended: 'error',
+    },
+    schema: [
+      {
+        type: "object",
+        required: ["types"],
+        properties: {
+          types: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["ban"],
+              properties: {
+                ban: { type: "string" },
+                safe: { type: "string" },
+                ignoreInGeneric: { type: "boolean" },
+              },
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      noExportedTypes:
+        '타입 "{{typeName}}"은(는) 공개적으로 노출되어서는 안됩니다.{{safeSuggestion}}',
+    },
+  },
+
+  defaultOptions: [{ types: [] }],
+
+  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 parserServices = ESLintUtils.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+    const typeCache = new WeakMap();
+
+    function getCachedType(tsNode) {
+      if (typeCache.has(tsNode)) return typeCache.get(tsNode);
+      const type = checker.getTypeAtLocation(tsNode);
+      typeCache.set(tsNode, type);
+      return type;
+    }
+
+    function isBannedTypeRecursive(type) {
+      const visited = new Set();
+
+      function visit(t) {
+        if (visited.has(t)) return undefined;
+        visited.add(t);
+
+        const name = t.aliasSymbol?.escapedName ?? t.symbol?.escapedName;
+        if (typeof name === "string" && bannedTypeNames.has(name)) {
+          const entry = optTypeMap.get(name);
+          if (entry.ignoreInGeneric) return undefined;
+          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)
+            : [];
+
+        for (const arg of typeArgs) {
+          const match = visit(arg);
+          if (match) return match;
+        }
+
+        if (t.isUnionOrIntersection?.()) {
+          for (const sub of t.types) {
+            const match = visit(sub);
+            if (match) return match;
+          }
+        }
+
+        const elementType = t.getNumberIndexType?.();
+        if (elementType) {
+          const match = visit(elementType);
+          if (match) return match;
+        }
+
+        return undefined;
+      }
+
+      return visit(type);
+    }
+
+    function reportIfBanned(type, node) {
+      const match = isBannedTypeRecursive(type);
+      if (match) {
+        context.report({
+          node,
+          messageId: "noExportedTypes",
+          data: {
+            typeName: match.ban,
+            safeSuggestion: match.safe
+              ? ` 더 안전한 대체 타입 "${match.safe}"을(를) 사용하세요.`
+              : "",
+          },
+        });
+      }
+    }
+
+    return {
+      FunctionDeclaration(node) {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const isExported =
+          (ts.getCombinedModifierFlags(tsNode) & ts.ModifierFlags.Export) !== 0;
+        if (!isExported) return;
+
+        const signature = checker.getSignatureFromDeclaration(tsNode);
+        if (!signature) return;
+
+        reportIfBanned(checker.getReturnTypeOfSignature(signature), node);
+
+        for (const param of node.params) {
+          const tsParam = parserServices.esTreeNodeToTSNodeMap.get(param);
+          reportIfBanned(getCachedType(tsParam), param);
+        }
+      },
+
+      MethodDefinition(node) {
+        const isConstructor = node.kind === "constructor";
+        const isPublic =
+          node.accessibility !== "private" &&
+          node.accessibility !== "protected";
+        if (!isConstructor && !isPublic) return;
+
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.value);
+        const signature = checker.getSignatureFromDeclaration(tsNode);
+        if (!signature) return;
+
+        if (!isConstructor) {
+          reportIfBanned(checker.getReturnTypeOfSignature(signature), node);
+        }
+
+        for (const param of node.value.params) {
+          const tsParam = parserServices.esTreeNodeToTSNodeMap.get(param);
+          reportIfBanned(getCachedType(tsParam), param);
+        }
+      },
+
+      PropertyDefinition(node) {
+        const isPublic =
+          node.accessibility !== "private" && node.accessibility !== "protected";
+        if (!isPublic) return;
+
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        reportIfBanned(getCachedType(tsNode), node);
+      },
+
+      VariableDeclarator(node) {
+        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        let modParent = tsNode.parent;
+        while (modParent && !("modifiers" in modParent)) {
+          modParent = modParent.parent;
+        }
+        if (!modParent || !("modifiers" in modParent)) return;
+
+        const isExported = (modParent.modifiers ?? []).some(
+          (m) => m.kind === ts.SyntaxKind.ExportKeyword,
+        );
+        if (!isExported) return;
+
+        let type;
+        if (node.id.typeAnnotation) {
+          const tsType = parserServices.esTreeNodeToTSNodeMap.get(
+            node.id.typeAnnotation.typeAnnotation,
+          );
+          type = checker.getTypeFromTypeNode(tsType);
+        }
+        else if (node.init) {
+          const tsInit = parserServices.esTreeNodeToTSNodeMap.get(node.init);
+          type = getCachedType(tsInit);
+        }
+
+        if (type) {
+          reportIfBanned(type, node.id);
+        }
+      },
+    };
+  },
+};