@kurateh/eslint-plugin 0.1.0

package/dist/index.mjs

@@ -0,0 +1,400 @@
+import { createRequire } from 'module';
+import react from 'eslint-plugin-react';
+import reactHook from 'eslint-plugin-react-hooks';
+import globals from 'globals';
+import importPlugin from 'eslint-plugin-import';
+import tseslint from 'typescript-eslint';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { ESLintUtils } from '@typescript-eslint/utils';
+import js from '@eslint/js';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+import unusedImportsPlugin from 'eslint-plugin-unused-imports';
+
+createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+// src/rules/import-path.ts
+var TS_CONFIG_FILE_NAMES = ["tsconfig.path.json", "tsconfig.json"];
+var has = (map, path) => {
+  let inner = map;
+  for (const step of path.split(".")) {
+    inner = inner[step];
+    if (inner === void 0) {
+      return false;
+    }
+  }
+  return true;
+};
+var findFilePath = (filename, initialPath) => {
+  let dir = initialPath;
+  do {
+    dir = dirname(dir);
+  } while (!existsSync(join(dir, filename)) && dir !== "/");
+  const filePath = join(dir, filename);
+  if (!existsSync(filePath)) {
+    return;
+  }
+  return filePath;
+};
+var getAbsolutePathInfo = (fileName) => {
+  for (const configPath of TS_CONFIG_FILE_NAMES) {
+    const filePath = findFilePath(configPath, fileName);
+    if (filePath === void 0) {
+      continue;
+    }
+    const baseDir = dirname(filePath);
+    const tsPathConfig = JSON.parse(
+      readFileSync(filePath, {
+        encoding: "utf-8"
+      })
+    );
+    const result = {
+      baseUrl: "",
+      paths: {}
+    };
+    if (has(tsPathConfig, "compilerOptions.baseUrl")) {
+      result.baseUrl = join(baseDir, tsPathConfig.compilerOptions.baseUrl);
+    }
+    if (has(tsPathConfig, "compilerOptions.paths")) {
+      result.paths = Object.fromEntries(
+        Object.entries(tsPathConfig.compilerOptions.paths).map(
+          ([key, value]) => [
+            key.replace(/\/\*$/, "/"),
+            value.map((path) => join(baseDir, path).replace(/\/\*$/, "/"))
+          ]
+        )
+      );
+    }
+    return result;
+  }
+  return;
+};
+var import_path_default = createRule({
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    messages: {
+      shouldBeRelativePath: 'When importing a child module, you must use the relative path. Use "{{expectedPath}}" instead of "{{source}}".',
+      shouldBeAbsolutePath: 'When importing a parent module, you must use the absolute path. Use "{{expectedPath}}" instead of "{{source}}".'
+    },
+    schema: [],
+    docs: {
+      description: "Enforce import path according to the location of the imported file."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    return {
+      ImportDeclaration: (node) => {
+        const fileName = context.getFilename();
+        const absolutePathInfo = getAbsolutePathInfo(fileName);
+        if (absolutePathInfo === void 0) {
+          return;
+        }
+        const source = node.source.value;
+        if (source.startsWith("..")) {
+          const sourceAbsolutePath2 = join(dirname(fileName), source);
+          for (const [alias, paths] of Object.entries(absolutePathInfo.paths)) {
+            for (const path of paths) {
+              if (sourceAbsolutePath2.startsWith(path)) {
+                const expectedPath2 = sourceAbsolutePath2.replace(path, alias);
+                context.report({
+                  node,
+                  messageId: "shouldBeAbsolutePath",
+                  data: {
+                    expectedPath: expectedPath2,
+                    source
+                  },
+                  fix(fixer) {
+                    return fixer.replaceText(node.source, `"${expectedPath2}"`);
+                  }
+                });
+                return;
+              }
+            }
+          }
+          return;
+        }
+        let sourceAbsolutePath;
+        for (const [alias, paths] of Object.entries(absolutePathInfo.paths)) {
+          for (const path of paths) {
+            if (source.startsWith(alias)) {
+              sourceAbsolutePath = join(path, source.replace(alias, ""));
+              break;
+            }
+          }
+          if (sourceAbsolutePath !== void 0) {
+            break;
+          }
+        }
+        if (sourceAbsolutePath === void 0) {
+          return;
+        }
+        const sourceRelativePath = relative(
+          dirname(fileName),
+          sourceAbsolutePath
+        );
+        if (sourceRelativePath.startsWith("..")) {
+          return;
+        }
+        const expectedPath = "./" + sourceRelativePath;
+        context.report({
+          node,
+          messageId: "shouldBeRelativePath",
+          data: {
+            expectedPath,
+            source
+          },
+          fix(fixer) {
+            return fixer.replaceText(node.source, `"${expectedPath}"`);
+          }
+        });
+        return;
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules_default = {
+  "import-path": import_path_default
+};
+var recommended_default = [
+  js.configs.recommended,
+  importPlugin.flatConfigs.recommended,
+  eslintPluginPrettierRecommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: "module",
+      globals: __spreadValues(__spreadValues(__spreadValues({}, globals.es2017), globals.browser), globals.node)
+    },
+    plugins: {
+      "unused-imports": unusedImportsPlugin
+    },
+    ignores: ["node_modules/", "dist/", "build/", "coverage/"],
+    rules: {
+      // eslint
+      "object-shorthand": 1,
+      "no-unused-vars": [
+        1,
+        {
+          ignoreRestSiblings: true,
+          vars: "all",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_"
+        }
+      ],
+      "no-param-reassign": [
+        2,
+        {
+          props: true,
+          ignorePropertyModificationsForRegex: ["^draft$", "Draft$"]
+        }
+      ],
+      camelcase: [1, { allow: ["^\\w*_[A-Z]*$"] }],
+      "no-var": 2,
+      // prettier
+      "prettier/prettier": [
+        1,
+        {
+          trailingComma: "all",
+          tabWidth: 2,
+          semi: true,
+          singleQuote: false,
+          endOfLine: "auto"
+        },
+        {
+          usePrettierrc: false
+        }
+      ],
+      // import
+      "import/no-unresolved": 0,
+      "import/no-extraneous-dependencies": [
+        2,
+        {
+          devDependencies: [
+            "**/*.test.*",
+            "**/*.stories.*",
+            "**/*.config.*",
+            "**/*.spec.*"
+          ]
+        }
+      ],
+      "import/order": [
+        1,
+        {
+          alphabetize: {
+            order: "asc",
+            caseInsensitive: true
+          },
+          "newlines-between": "always",
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            ["parent", "sibling", "index"]
+          ],
+          pathGroups: [
+            {
+              pattern: "~*/**",
+              group: "internal"
+            },
+            {
+              pattern: "@*/**",
+              group: "internal"
+            }
+          ]
+        }
+      ],
+      // unused-imports
+      "unused-imports/no-unused-imports": 2
+    }
+  }
+];
+
+// src/configs/typescript.ts
+var typescript_default = [
+  ...recommended_default,
+  // eslint-disable-next-line import/no-named-as-default-member
+  ...tseslint.configs.recommended,
+  importPlugin.flatConfigs.typescript,
+  {
+    // ESLint config block에 file이 있으면 해당 파일을 검사할 차례가 와서야 plugin이 적용됨
+    // 따라서 이 Plugin을 끄려면 Config File에서 file: "~~"을 넣어야 됨
+    // 이 과정을 없애기 위해 plugin 적용을 앞서 진행
+    plugins: {
+      "@kurateh": { rules: rules_default, meta: { name: "@kurateh" } }
+    }
+  },
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+          // always try to resolve types under `<root>@types` directory even it doesn't contain any source code, like `@types/unist`
+          // Choose from one of the "project" configs below or omit to use <root>/tsconfig.json by default
+          // use <root>/path/to/folder/tsconfig.json
+          project: "tsconfig.json"
+          // Multiple tsconfigs (Useful for monorepos)
+          // use a glob pattern
+          // project: "packages/*/tsconfig.json",
+          // use an array
+          // project: [
+          //   "packages/module-a/tsconfig.json",
+          //   "packages/module-b/tsconfig.json"
+          // ],
+          // use an array of glob patterns
+          // project: [
+          //   "packages/*/tsconfig.json",
+          //   "other-packages/*/
+        }
+      }
+    },
+    rules: {
+      // eslint
+      "@kurateh/import-path": 1,
+      "object-shorthand": 1,
+      "no-unused-vars": 0,
+      "@typescript-eslint/no-unused-vars": [
+        1,
+        {
+          ignoreRestSiblings: true,
+          vars: "all",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_"
+        }
+      ],
+      "@typescript-eslint/consistent-type-imports": [
+        1,
+        {
+          fixStyle: "inline-type-imports"
+        }
+      ],
+      "no-param-reassign": [
+        2,
+        {
+          props: true,
+          ignorePropertyModificationsForRegex: ["^draft$", "Draft$"]
+        }
+      ],
+      camelcase: [1, { allow: ["^\\w*_[A-Z]*$"] }],
+      "no-var": 2,
+      "import-plugin/no-unresolved": 0
+    }
+  }
+];
+
+// src/configs/react.ts
+var _a, _b;
+var react_default = [
+  ...typescript_default,
+  (_b = (_a = react.configs.flat) == null ? void 0 : _a.recommended) != null ? _b : {},
+  {
+    plugins: { "react-hooks": reactHook },
+    files: ["**/*.{js,jsx,mjs,cjs,ts,tsx}"],
+    languageOptions: {
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        }
+      },
+      globals: __spreadValues({}, globals.browser)
+    },
+    rules: __spreadProps(__spreadValues({}, reactHook.configs.recommended.rules), {
+      "react/react-in-jsx-scope": 0,
+      "react/function-component-definition": [
+        2,
+        {
+          namedComponents: "arrow-function",
+          unnamedComponents: "arrow-function"
+        }
+      ],
+      "react/jsx-curly-brace-presence": [
+        1,
+        {
+          props: "never",
+          children: "never"
+        }
+      ],
+      "react/prop-types": 0,
+      "react/require-default-props": 0,
+      "react/display-name": 0
+    })
+  }
+];
+
+// src/index.ts
+var index_default = {
+  configs: {
+    recommended: recommended_default,
+    typescript: typescript_default,
+    react: react_default
+  },
+  rules: rules_default
+};
+
+export { index_default as default };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kurateh/eslint-plugin",
+  "version": "0.1.0",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eslint",
+    "plugin"
+  ],
+  "license": "ISC",
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@kurateh/eslint-plugin": "file:",
+    "@types/node": "^22.10.2",
+    "@types/react": "^19.0.2",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "react": "^19.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@eslint/js": "^9.17.0",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
+    "@typescript-eslint/utils": "^8.18.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-react": "^7.37.2",
+    "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "globals": "^15.14.0",
+    "typescript-eslint": "^8.18.1"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint .",
+    "type-check": "tsc --noEmit",
+    "version": "npm version"
+  }
+}