@simplysm/eslint-plugin 7.0.25 → 7.0.39

package/.eslintrc.cjs

@@ -1 +1 @@
-module.exports = {};
+module.exports = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplysm/eslint-plugin",
-  "version": "7.0.25",
+  "version": "7.0.39",
   "description": "심플리즘 패키지 - ESLINT 플러그인",
   "author": "김석래",
   "repository": {
@@ -18,7 +18,12 @@
   "dependencies": {
     "eslint": "^8.7.0",
     "@typescript-eslint/parser": "^5.10.1",
-    "@typescript-eslint/eslint-plugin": "^5.10.1"
+    "@typescript-eslint/eslint-plugin": "^5.10.1",
+    "@angular-eslint/eslint-plugin": "^13.0.1",
+    "@angular-eslint/eslint-plugin-template": "^13.0.1",
+    "@angular-eslint/template-parser": "^13.0.1",
+    "@typescript-eslint/experimental-utils": "^5.10.2",
+    "eslint-module-utils": "^2.7.3"
   },
   "devDependencies": {},
   "peerDependencies": {}

package/src/configs/angular-template.cjs

@@ -0,0 +1,10 @@
+module.exports = {
+  parser: "@angular-eslint/template-parser",
+  plugins: [
+    "@angular-eslint/template",
+    "@simplysm"
+  ],
+  rules: {
+    "@simplysm/ng-template-no-todo-comments": "warn"
+  }
+};

package/src/configs/angular.cjs

@@ -0,0 +1,5 @@
+module.exports = {
+  plugins: ["@angular-eslint"],
+  processor: "@angular-eslint/template/extract-inline-html",
+  rules: {}
+};

package/src/configs/base.cjs

@@ -1,4 +1,8 @@
 module.exports = {
+  env: {
+    node: true,
+    es2020: true
+  },
   rules: {
     "require-await": ["error"],
     "quotes": ["error"],
@@ -6,6 +10,8 @@ module.exports = {
     "no-shadow": ["error"],
     "no-duplicate-imports": ["error"],
     "no-unused-expressions": ["error"],
-    "no-unused-vars": ["error"]
+    "no-unused-vars": ["error"],
+    "no-undef": ["error"],
+    "comma-dangle": ["error"]
   }
 };

package/src/configs/typescript.cjs

@@ -1,7 +1,18 @@
 module.exports = {
   parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint"],
+  plugins: [
+    "@typescript-eslint",
+    "@simplysm"
+  ],
+  // extends: [
+  //   "plugin:@typescript-eslint/all"
+  // ],
   rules: {
+    // 심플리즘
+    "@simplysm/ts-no-throw-not-implement-error": "warn",
+    "@simplysm/ts-no-self-entry-import": "error",
+
+    // 타입스크립트
     "@typescript-eslint/explicit-member-accessibility": ["error"],
     "@typescript-eslint/require-await": ["error"],
     "@typescript-eslint/await-thenable": ["error"],
@@ -25,6 +36,14 @@ module.exports = {
       allowConciseArrowFunctionExpressionsStartingWithVoid: true
     }],
     "@typescript-eslint/no-unused-expressions": ["error"],
-    "@typescript-eslint/no-unused-vars": ["error"]
+    "@typescript-eslint/no-unused-vars": ["warn", { args: "none" }],
+    "@typescript-eslint/strict-boolean-expressions": ["error", {
+      allowNullableBoolean: true,
+      allowNullableObject: true
+    }],
+    "@typescript-eslint/explicit-module-boundary-types": ["error", { allowArgumentsExplicitlyTypedAsAny: true }],
+    "@typescript-eslint/return-await": ["error", "always"],
+    "@typescript-eslint/no-floating-promises": ["error"],
+    "@typescript-eslint/comma-dangle": ["error"]
   }
 };

package/src/index.cjs

@@ -1,8 +1,13 @@
 module.exports = {
   configs: {
     "base": require("./configs/base.cjs"),
-    "typescript": require("./configs/typescript.cjs")
+    "typescript": require("./configs/typescript.cjs"),
+    "angular": require("./configs/angular.cjs"),
+    "angular-template": require("./configs/angular-template.cjs")
   },
-  rules: {},
-  processors: {}
-};
+  rules: {
+    "ts-no-self-entry-import": require("./rules/ts-no-self-entry-import.cjs"),
+    "ts-no-throw-not-implement-error": require("./rules/ts-no-throw-not-implement-error.cjs"),
+    "ng-template-no-todo-comments": require("./rules/ng-template-no-todo-comments.cjs")
+  }
+};

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

@@ -0,0 +1,45 @@
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "'TODO' 주석 경고"
+    },
+
+    schema: []
+  },
+
+  create: (context) => {
+    // const parserServices = context.parserServices;
+    return {
+      Program(node) {
+        if (node.value) {
+          const comments = node.value.match(/<!--(((?!-->)[\s\S])*)-->/g);
+          if (!comments) return;
+
+          let cursor = 0;
+          for (const comment of comments) {
+            if (!comment.includes("TODO:")) continue;
+
+            const index = node.value.slice(cursor).indexOf(comment) + cursor;
+            const line = node.value.slice(0, index).split("\n").length;
+            const column = index - node.value.slice(0, index).lastIndexOf("\n") - 1;
+
+            const endIndex = index + comment.length;
+            const endLine = node.value.slice(0, endIndex).split("\n").length;
+            const endColumn = endIndex - node.value.slice(0, endIndex).lastIndexOf("\n") - 1;
+
+            cursor += index;
+
+            context.report({
+              loc: {
+                start: { line, column },
+                end: { line: endLine, column: endColumn }
+              },
+              message: comment.match(/<!--(((?!-->)[\s\S])*)-->/)[1].trim()
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/src/rules/ts-no-self-entry-import.cjs

@@ -0,0 +1,64 @@
+const resolve = require("eslint-module-utils/resolve").default;
+const path = require("path");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "동일 패키지 내의 index.ts 파일 import 금지"
+    },
+
+    schema: []
+  },
+  create: (context) => {
+    const filePath = context.getFilename();
+    const importMap = new Map();
+
+    function append(requirePath, node) {
+      if (filePath !== "<text>" && (requirePath.endsWith(".") || requirePath.endsWith("/"))) {
+        const resolvedPath = (resolve(requirePath, context) || requirePath).toLowerCase();
+        if (resolvedPath) {
+          if (importMap.has(resolvedPath)) {
+            importMap.get(resolvedPath).push(node);
+          }
+          else {
+            importMap.set(resolvedPath, [node]);
+          }
+        }
+      }
+    }
+
+    return {
+      "ImportDeclaration": (node) => {
+        append(node.source.value, node);
+      },
+      "CallExpression": (node) => {
+        if (
+          node
+          && node.callee
+          && node.callee.type === "Identifier"
+          && node.callee.name === "require"
+          && node.arguments.length === 1
+          && node.arguments[0].type === "Literal"
+          && typeof node.arguments[0].value === "string"
+        ) {
+          append(node.arguments[0].value, node);
+        }
+      },
+      "Program:exit": () => {
+        const rootFileNames = context.parserServices.program.getRootFileNames()
+          .map((item) => path.normalize(item).toLowerCase());
+        for (const rootFileName of rootFileNames) {
+          if (importMap.has(rootFileName)) {
+            for (const node of importMap.get(rootFileName)) {
+              context.report({
+                node,
+                message: "동일 패키지상의 index.ts 파일을 import 하고 있습니다."
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+};

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

@@ -0,0 +1,73 @@
+const { AST_NODE_TYPES } = require("@typescript-eslint/experimental-utils");
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "'NotImplementError' 사용 경고"
+    },
+
+    schema: []
+  },
+  create: (context) => {
+    const parserServices = context.parserServices;
+    const program = parserServices.program;
+    const checker = program.getTypeChecker();
+
+    function 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.AssignmentExpression:
+          return tryGetThrowArgumentType(node.right);
+
+        case AST_NODE_TYPES.SequenceExpression:
+          return tryGetThrowArgumentType(node.expressions[node.expressions.length - 1]);
+
+        case AST_NODE_TYPES.LogicalExpression: {
+          const left = tryGetThrowArgumentType(node.left);
+          return left === undefined ? tryGetThrowArgumentType(node.right) : left;
+        }
+
+        case AST_NODE_TYPES.ConditionalExpression: {
+          const consequent = tryGetThrowArgumentType(node.consequent);
+          return consequent === undefined ? tryGetThrowArgumentType(node.alternate) : consequent;
+        }
+
+        default:
+          return undefined;
+      }
+    }
+
+    function 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") {
+        context.report({
+          node,
+          message: node.arguments.value || "구현되어있지 않습니다" //"'NotImplementError'를 'throw'하고 있습니다."
+        });
+      }
+    }
+
+    return {
+      ThrowStatement(node) {
+        if (node.argument) {
+          checkThrowArgument(node.argument);
+        }
+      }
+    };
+  }
+};