eslint-plugin-hyoban 0.1.10 → 0.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2019-PRESENT Anthony Fu<https://github.com/antfu>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Stephen Zhou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# eslint-plugin-hyoban
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+
+Prefer early return pattern to clean if else statement
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-hyoban?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/eslint-plugin-hyoban
+[npm-downloads-src]: https://img.shields.io/npm/dm/eslint-plugin-hyoban?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/eslint-plugin-hyoban
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/eslint-plugin-hyoban?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=eslint-plugin-hyoban
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/eslint-plugin-hyoban

package/dist/index.cjs

@@ -1,236 +1,117 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-const utils = require('@typescript-eslint/utils');
+var utils = require('@typescript-eslint/utils');
 
-const createEslintRule = utils.ESLintUtils.RuleCreator(
-  (ruleName) => ruleName
-);
+var version = "0.2.0";
 
-const RULE_NAME$3 = "generic-spacing";
-const genericSpacing = createEslintRule({
-  name: RULE_NAME$3,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Spaces around generic type parameters",
-      recommended: "error"
+const createRule = utils.ESLintUtils.RuleCreator((name)=>`https://github.com/hyoban/eslint-plugin-hyoban/blob/main/src/rules/${name}.`);
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+const rule$1 = createRule({
+    name: 'no-extra-space-jsx-expression',
+    meta: {
+        type: 'layout',
+        fixable: 'whitespace',
+        docs: {
+            description: 'No extra space in jsx expression'
+        },
+        messages: {
+            noExtraSpaceJsxExpression: 'No extra space in jsx expression'
+        },
+        schema: []
     },
-    fixable: "code",
-    schema: [],
-    messages: {
-      genericSpacingMismatch: "Generic spaces mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      TSTypeParameterDeclaration: (node) => {
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression", "TSFunctionType"].includes(node.parent.type)) {
-          const pre = sourceCode.text.slice(0, node.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          if (preSpace && preSpace.length) {
+    defaultOptions: [],
+    create (context) {
+        function check(node, isExit) {
+            const { expression } = node;
+            if (expression.type !== utils.AST_NODE_TYPES.CallExpression && expression.type !== utils.AST_NODE_TYPES.ChainExpression) return;
+            const containerRange = node.range;
+            const expressionRange = expression.range;
+            if (containerRange[1] - expressionRange[1] === 1 && expressionRange[0] - containerRange[0] === 1) return;
             context.report({
-              node,
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([node.range[0] - preSpace.length, node.range[0]], "");
-              }
+                node,
+                messageId: 'noExtraSpaceJsxExpression',
+                fix (fixer) {
+                    return isExit ? fixer.removeRange([
+                        expressionRange[1],
+                        containerRange[1] - 1
+                    ]) : fixer.removeRange([
+                        containerRange[0] + 1,
+                        expressionRange[0]
+                    ]);
+                }
             });
-          }
         }
-        const params = node.params;
-        for (let i = 1; i < params.length; i++) {
-          const prev = params[i - 1];
-          const current = params[i];
-          const from = prev.range[1];
-          const to = current.range[0];
-          const span = sourceCode.text.slice(from, to);
-          if (span !== ", " && !span.match(/,\n/)) {
-            context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([from, to], ", ");
-              },
-              loc: {
-                start: prev.loc.end,
-                end: current.loc.start
-              },
-              messageId: "genericSpacingMismatch",
-              node
-            });
-          }
-        }
-      },
-      TSTypeParameter: (node) => {
-        if (!node.default)
-          return;
-        const endNode = node.constraint || node.name;
-        const from = endNode.range[1];
-        const to = node.default.range[0];
-        if (sourceCode.text.slice(from, to) !== " = ") {
-          context.report({
-            *fix(fixer) {
-              yield fixer.replaceTextRange([from, to], " = ");
-            },
-            loc: {
-              start: endNode.loc.end,
-              end: node.default.loc.start
+        return {
+            'JSXExpressionContainer:exit' (node) {
+                check(node, true);
             },
-            messageId: "genericSpacingMismatch",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$2 = "if-newline";
-const ifNewline = createEslintRule({
-  name: RULE_NAME$2,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Newline after if",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      missingIfNewline: "Expect newline after if"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    return {
-      IfStatement(node) {
-        if (!node.consequent)
-          return;
-        if (node.consequent.type === "BlockStatement")
-          return;
-        if (node.test.loc.end.line === node.consequent.loc.start.line) {
-          context.report({
-            node,
-            loc: {
-              start: node.test.loc.end,
-              end: node.consequent.loc.start
-            },
-            messageId: "missingIfNewline",
-            fix(fixer) {
-              return fixer.replaceTextRange([node.consequent.range[0], node.consequent.range[0]], "\n");
+            JSXExpressionContainer (node) {
+                check(node);
             }
-          });
-        }
-      }
-    };
-  }
+        };
+    }
 });
 
-const RULE_NAME$1 = "import-dedupe";
-const importDedupe = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Fix duplication in imports",
-      recommended: "error"
+// eslint-disable-next-line unused-imports/no-unused-imports
+function isConditionRevertNeedBracket(node) {
+    return !(node.type === utils.AST_NODE_TYPES.Identifier || node.type === utils.AST_NODE_TYPES.Literal || node.type === utils.AST_NODE_TYPES.MemberExpression || node.type === utils.AST_NODE_TYPES.CallExpression);
+}
+function getIndentation(node) {
+    return ' '.repeat(node.loc.start.column);
+}
+function isNodeNeedEarlyReturn(node) {
+    return node.type === utils.AST_NODE_TYPES.ReturnStatement || node.type === utils.AST_NODE_TYPES.ThrowStatement || node.type === utils.AST_NODE_TYPES.ContinueStatement;
+}
+const rule = createRule({
+    name: 'prefer-early-return',
+    meta: {
+        docs: {
+            description: 'Prefer early return pattern to clean if else statement'
+        },
+        messages: {
+            preferEarlyReturn: 'Return early to clean this if else statement'
+        },
+        type: 'suggestion',
+        schema: [],
+        fixable: 'code'
     },
-    fixable: "code",
-    schema: [],
-    messages: {
-      importDedupe: "Expect no duplication in imports"
+    defaultOptions: [],
+    create (context) {
+        return {
+            IfStatement (node) {
+                if (!node.alternate) return;
+                if (isNodeNeedEarlyReturn(node.alternate) || node.alternate.type === utils.AST_NODE_TYPES.BlockStatement && node.alternate.body.some((statement)=>isNodeNeedEarlyReturn(statement))) {
+                    context.report({
+                        node: node.alternate,
+                        messageId: 'preferEarlyReturn',
+                        fix (fixer) {
+                            const condition = context.sourceCode.getText(node.test);
+                            const revertCondition = isConditionRevertNeedBracket(node.test) ? `!(${condition})` : `!${condition}`;
+                            let ifText = context.sourceCode.getText(node.consequent);
+                            ifText = ifText.startsWith('{') && ifText.endsWith('}') ? ifText.replace(/^{/, '').replace(/}$/, '').replaceAll('\n  ', '\n').slice(1, -1) : `${getIndentation(node)}${ifText}`;
+                            const elseText = context.sourceCode.getText(node.alternate);
+                            return [
+                                fixer.replaceText(node, `if (${revertCondition}) ${elseText}\n${ifText}`)
+                            ];
+                        }
+                    });
+                }
+            }
+        };
     }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1)
-          return;
-        const names = /* @__PURE__ */ new Set();
-        node.specifiers.forEach((n) => {
-          const id = n.local.name;
-          if (names.has(id)) {
-            context.report({
-              node,
-              loc: {
-                start: n.loc.end,
-                end: n.loc.start
-              },
-              messageId: "importDedupe",
-              fix(fixer) {
-                const s = n.range[0];
-                let e = n.range[1];
-                if (context.getSourceCode().text[e] === ",")
-                  e += 1;
-                return fixer.removeRange([s, e]);
-              }
-            });
-          }
-          names.add(id);
-        });
-      }
-    };
-  }
 });
 
-const RULE_NAME = "prefer-inline-type-import";
-const preferInlineTypeImport = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Newline after if",
-      recommended: "error"
+// eslint-disable-next-line unused-imports/no-unused-imports
+var index = {
+    meta: {
+        name: 'hyoban',
+        version
     },
-    fixable: "code",
-    schema: [],
-    messages: {
-      preferInlineTypeImport: "Prefer inline type import"
+    rules: {
+        'prefer-early-return': rule,
+        'no-extra-space-jsx-expression': rule$1
     }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      ImportDeclaration: (node) => {
-        if (node.specifiers.length === 1 && ["ImportNamespaceSpecifier", "ImportDefaultSpecifier"].includes(node.specifiers[0].type))
-          return;
-        if (node.importKind === "type") {
-          context.report({
-            *fix(fixer) {
-              yield* removeTypeSpecifier(fixer, sourceCode, node);
-              for (const specifier of node.specifiers)
-                yield fixer.insertTextBefore(specifier, "type ");
-            },
-            loc: node.loc,
-            messageId: "preferInlineTypeImport",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-function* removeTypeSpecifier(fixer, sourceCode, node) {
-  const importKeyword = sourceCode.getFirstToken(node);
-  const typeIdentifier = sourceCode.getTokenAfter(importKeyword);
-  yield fixer.remove(typeIdentifier);
-  if (importKeyword.loc.end.column + 1 === typeIdentifier.loc.start.column) {
-    yield fixer.removeRange([
-      importKeyword.range[1],
-      importKeyword.range[1] + 1
-    ]);
-  }
-}
-
-const index = {
-  rules: {
-    "if-newline": ifNewline,
-    "import-dedupe": importDedupe,
-    "prefer-inline-type-import": preferInlineTypeImport,
-    "generic-spacing": genericSpacing
-  }
 };
 
-module.exports = index;
+exports.default = index;

package/dist/index.d.cts

@@ -0,0 +1,14 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'prefer-early-return': ESLintUtils.RuleModule<"preferEarlyReturn", [], ESLintUtils.RuleListener>;
+        'no-extra-space-jsx-expression': ESLintUtils.RuleModule<"noExtraSpaceJsxExpression", [], ESLintUtils.RuleListener>;
+    };
+};
+
+export { _default as default };

package/dist/index.d.ts

@@ -1,11 +1,13 @@
-import * as _typescript_eslint_utils_dist_ts_eslint_Rule from '@typescript-eslint/utils/dist/ts-eslint/Rule';
+import { ESLintUtils } from '@typescript-eslint/utils';
 
 declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+    };
     rules: {
-        'if-newline': _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"missingIfNewline", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
-        'import-dedupe': _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"importDedupe", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
-        'prefer-inline-type-import': _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"preferInlineTypeImport", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
-        'generic-spacing': _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"genericSpacingMismatch", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
+        'prefer-early-return': ESLintUtils.RuleModule<"preferEarlyReturn", [], ESLintUtils.RuleListener>;
+        'no-extra-space-jsx-expression': ESLintUtils.RuleModule<"noExtraSpaceJsxExpression", [], ESLintUtils.RuleListener>;
     };
 };
 

package/dist/index.js

@@ -0,0 +1,115 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+var version = "0.2.0";
+
+const createRule = ESLintUtils.RuleCreator((name)=>`https://github.com/hyoban/eslint-plugin-hyoban/blob/main/src/rules/${name}.`);
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+const rule$1 = createRule({
+    name: 'no-extra-space-jsx-expression',
+    meta: {
+        type: 'layout',
+        fixable: 'whitespace',
+        docs: {
+            description: 'No extra space in jsx expression'
+        },
+        messages: {
+            noExtraSpaceJsxExpression: 'No extra space in jsx expression'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create (context) {
+        function check(node, isExit) {
+            const { expression } = node;
+            if (expression.type !== AST_NODE_TYPES.CallExpression && expression.type !== AST_NODE_TYPES.ChainExpression) return;
+            const containerRange = node.range;
+            const expressionRange = expression.range;
+            if (containerRange[1] - expressionRange[1] === 1 && expressionRange[0] - containerRange[0] === 1) return;
+            context.report({
+                node,
+                messageId: 'noExtraSpaceJsxExpression',
+                fix (fixer) {
+                    return isExit ? fixer.removeRange([
+                        expressionRange[1],
+                        containerRange[1] - 1
+                    ]) : fixer.removeRange([
+                        containerRange[0] + 1,
+                        expressionRange[0]
+                    ]);
+                }
+            });
+        }
+        return {
+            'JSXExpressionContainer:exit' (node) {
+                check(node, true);
+            },
+            JSXExpressionContainer (node) {
+                check(node);
+            }
+        };
+    }
+});
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+function isConditionRevertNeedBracket(node) {
+    return !(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.Literal || node.type === AST_NODE_TYPES.MemberExpression || node.type === AST_NODE_TYPES.CallExpression);
+}
+function getIndentation(node) {
+    return ' '.repeat(node.loc.start.column);
+}
+function isNodeNeedEarlyReturn(node) {
+    return node.type === AST_NODE_TYPES.ReturnStatement || node.type === AST_NODE_TYPES.ThrowStatement || node.type === AST_NODE_TYPES.ContinueStatement;
+}
+const rule = createRule({
+    name: 'prefer-early-return',
+    meta: {
+        docs: {
+            description: 'Prefer early return pattern to clean if else statement'
+        },
+        messages: {
+            preferEarlyReturn: 'Return early to clean this if else statement'
+        },
+        type: 'suggestion',
+        schema: [],
+        fixable: 'code'
+    },
+    defaultOptions: [],
+    create (context) {
+        return {
+            IfStatement (node) {
+                if (!node.alternate) return;
+                if (isNodeNeedEarlyReturn(node.alternate) || node.alternate.type === AST_NODE_TYPES.BlockStatement && node.alternate.body.some((statement)=>isNodeNeedEarlyReturn(statement))) {
+                    context.report({
+                        node: node.alternate,
+                        messageId: 'preferEarlyReturn',
+                        fix (fixer) {
+                            const condition = context.sourceCode.getText(node.test);
+                            const revertCondition = isConditionRevertNeedBracket(node.test) ? `!(${condition})` : `!${condition}`;
+                            let ifText = context.sourceCode.getText(node.consequent);
+                            ifText = ifText.startsWith('{') && ifText.endsWith('}') ? ifText.replace(/^{/, '').replace(/}$/, '').replaceAll('\n  ', '\n').slice(1, -1) : `${getIndentation(node)}${ifText}`;
+                            const elseText = context.sourceCode.getText(node.alternate);
+                            return [
+                                fixer.replaceText(node, `if (${revertCondition}) ${elseText}\n${ifText}`)
+                            ];
+                        }
+                    });
+                }
+            }
+        };
+    }
+});
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+var index = {
+    meta: {
+        name: 'hyoban',
+        version
+    },
+    rules: {
+        'prefer-early-return': rule,
+        'no-extra-space-jsx-expression': rule$1
+    }
+};
+
+export { index as default };

package/package.json

@@ -1,26 +1,88 @@
 {
   "name": "eslint-plugin-hyoban",
-  "version": "0.1.10",
+  "type": "module",
+  "version": "0.2.0",
+  "packageManager": "pnpm@8.15.4",
+  "description": "Prefer early return pattern to clean if else statement",
+  "author": {
+    "name": "hyoban",
+    "url": "https://github.com/hyoban"
+  },
   "license": "MIT",
-  "homepage": "https://github.com/hyoban/eslint-config",
+  "homepage": "https://github.com/hyoban/eslint-plugin-hyoban#readme",
+  "repository": "hyoban/eslint-plugin-hyoban",
+  "bugs": "https://github.com/hyoban/eslint-plugin-hyoban/issues",
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
   "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist"
   ],
+  "release-it": {
+    "plugins": {
+      "release-it-pnpm": {}
+    },
+    "git": {
+      "commitMessage": "chore: release v${version}"
+    },
+    "hooks": {
+      "before:init": [
+        "pnpm run lint",
+        "pnpm run typecheck",
+        "pnpm run test --run"
+      ]
+    }
+  },
   "dependencies": {
-    "@typescript-eslint/utils": "^5.47.1"
+    "@typescript-eslint/utils": "^7.1.1"
   },
   "devDependencies": {
-    "@types/node": "^18.11.18",
-    "rimraf": "^3.0.2",
-    "unbuild": "^1.0.2",
-    "vitest": "^0.26.2"
+    "@types/node": "^20.11.25",
+    "@typescript-eslint/rule-tester": "^7.1.1",
+    "bunchee": "^4.4.8",
+    "dedent": "^1.5.1",
+    "eslint": "^8.57.0",
+    "eslint-config-hyoban": "^0.1.33",
+    "lint-staged": "^15.2.2",
+    "release-it": "^17.1.1",
+    "release-it-pnpm": "4.0.0-beta.2",
+    "simple-git-hooks": "^2.10.0",
+    "typescript": "^5.4.2",
+    "vitest": "^1.3.1"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
   },
   "scripts": {
-    "build": "rimraf dist && unbuild",
-    "stub": "unbuild --stub",
-    "test": "vitest"
+    "build": "bunchee",
+    "dev": "bunchee -w",
+    "lint": "eslint .",
+    "test": "vitest",
+    "typecheck": "tsc"
   }
 }

package/dist/index.mjs

@@ -1,234 +0,0 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-const createEslintRule = ESLintUtils.RuleCreator(
-  (ruleName) => ruleName
-);
-
-const RULE_NAME$3 = "generic-spacing";
-const genericSpacing = createEslintRule({
-  name: RULE_NAME$3,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Spaces around generic type parameters",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      genericSpacingMismatch: "Generic spaces mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      TSTypeParameterDeclaration: (node) => {
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression", "TSFunctionType"].includes(node.parent.type)) {
-          const pre = sourceCode.text.slice(0, node.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          if (preSpace && preSpace.length) {
-            context.report({
-              node,
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([node.range[0] - preSpace.length, node.range[0]], "");
-              }
-            });
-          }
-        }
-        const params = node.params;
-        for (let i = 1; i < params.length; i++) {
-          const prev = params[i - 1];
-          const current = params[i];
-          const from = prev.range[1];
-          const to = current.range[0];
-          const span = sourceCode.text.slice(from, to);
-          if (span !== ", " && !span.match(/,\n/)) {
-            context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([from, to], ", ");
-              },
-              loc: {
-                start: prev.loc.end,
-                end: current.loc.start
-              },
-              messageId: "genericSpacingMismatch",
-              node
-            });
-          }
-        }
-      },
-      TSTypeParameter: (node) => {
-        if (!node.default)
-          return;
-        const endNode = node.constraint || node.name;
-        const from = endNode.range[1];
-        const to = node.default.range[0];
-        if (sourceCode.text.slice(from, to) !== " = ") {
-          context.report({
-            *fix(fixer) {
-              yield fixer.replaceTextRange([from, to], " = ");
-            },
-            loc: {
-              start: endNode.loc.end,
-              end: node.default.loc.start
-            },
-            messageId: "genericSpacingMismatch",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$2 = "if-newline";
-const ifNewline = createEslintRule({
-  name: RULE_NAME$2,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Newline after if",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      missingIfNewline: "Expect newline after if"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    return {
-      IfStatement(node) {
-        if (!node.consequent)
-          return;
-        if (node.consequent.type === "BlockStatement")
-          return;
-        if (node.test.loc.end.line === node.consequent.loc.start.line) {
-          context.report({
-            node,
-            loc: {
-              start: node.test.loc.end,
-              end: node.consequent.loc.start
-            },
-            messageId: "missingIfNewline",
-            fix(fixer) {
-              return fixer.replaceTextRange([node.consequent.range[0], node.consequent.range[0]], "\n");
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$1 = "import-dedupe";
-const importDedupe = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Fix duplication in imports",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      importDedupe: "Expect no duplication in imports"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1)
-          return;
-        const names = /* @__PURE__ */ new Set();
-        node.specifiers.forEach((n) => {
-          const id = n.local.name;
-          if (names.has(id)) {
-            context.report({
-              node,
-              loc: {
-                start: n.loc.end,
-                end: n.loc.start
-              },
-              messageId: "importDedupe",
-              fix(fixer) {
-                const s = n.range[0];
-                let e = n.range[1];
-                if (context.getSourceCode().text[e] === ",")
-                  e += 1;
-                return fixer.removeRange([s, e]);
-              }
-            });
-          }
-          names.add(id);
-        });
-      }
-    };
-  }
-});
-
-const RULE_NAME = "prefer-inline-type-import";
-const preferInlineTypeImport = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Newline after if",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      preferInlineTypeImport: "Prefer inline type import"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      ImportDeclaration: (node) => {
-        if (node.specifiers.length === 1 && ["ImportNamespaceSpecifier", "ImportDefaultSpecifier"].includes(node.specifiers[0].type))
-          return;
-        if (node.importKind === "type") {
-          context.report({
-            *fix(fixer) {
-              yield* removeTypeSpecifier(fixer, sourceCode, node);
-              for (const specifier of node.specifiers)
-                yield fixer.insertTextBefore(specifier, "type ");
-            },
-            loc: node.loc,
-            messageId: "preferInlineTypeImport",
-            node
-          });
-        }
-      }
-    };
-  }
-});
-function* removeTypeSpecifier(fixer, sourceCode, node) {
-  const importKeyword = sourceCode.getFirstToken(node);
-  const typeIdentifier = sourceCode.getTokenAfter(importKeyword);
-  yield fixer.remove(typeIdentifier);
-  if (importKeyword.loc.end.column + 1 === typeIdentifier.loc.start.column) {
-    yield fixer.removeRange([
-      importKeyword.range[1],
-      importKeyword.range[1] + 1
-    ]);
-  }
-}
-
-const index = {
-  rules: {
-    "if-newline": ifNewline,
-    "import-dedupe": importDedupe,
-    "prefer-inline-type-import": preferInlineTypeImport,
-    "generic-spacing": genericSpacing
-  }
-};
-
-export { index as default };