@so1ve/eslint-plugin 0.56.0 → 0.57.0

package/dist/index.cjs

@@ -1,369 +1,12 @@
 'use strict';
 
 const utils = require('@typescript-eslint/utils');
-const reactivity = require('@vue/reactivity');
-const util = require('@typescript-eslint/utils/dist/ast-utils');
-
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$8 = "array-bracket-spacing";
-const arrayBracketSpacing = createEslintRule({
-  name: RULE_NAME$8,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Array bracket spacing",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      arrayBracketSpacing: "Array bracket spacing mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.getText();
-    const checkNode = (node) => {
-      const elements = node.type === utils.AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
-      const firstElement = elements[0];
-      const lastElement = elements[elements.length - 1];
-      if (!firstElement) {
-        return;
-      }
-      const leftToken = sourceCode.getTokenBefore(firstElement);
-      const rightToken = reactivity.ref(sourceCode.getTokenAfter(lastElement));
-      if (rightToken.value.value === ",") {
-        rightToken.value = sourceCode.getTokenAfter(rightToken.value);
-      }
-      const textBetweenFirstAndToken = reactivity.computed(() => text.slice(leftToken.range[1], firstElement.range[0]));
-      const isNewline = reactivity.computed(() => textBetweenFirstAndToken.value.includes("\n"));
-      const textBetweenLastAndToken = reactivity.computed(() => text.slice(lastElement.range[1], rightToken.value.range[0]));
-      const hasNewlineAfter = reactivity.computed(() => textBetweenLastAndToken.value.includes("\n"));
-      if (sourceCode.isSpaceBetween(leftToken, firstElement) && !isNewline.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.removeRange([leftToken.range[1], firstElement.range[0]]);
-          }
-        });
-      }
-      if (sourceCode.isSpaceBetween(lastElement, rightToken.value)) {
-        if (!isNewline.value) {
-          context.report({
-            node,
-            messageId: "arrayBracketSpacing",
-            *fix(fixer) {
-              yield fixer.removeRange([lastElement.range[1], rightToken.value.range[0]]);
-            }
-          });
-        }
-      }
-      if (isNewline.value && !hasNewlineAfter.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.replaceTextRange([lastElement.range[1], rightToken.value.range[0]], "\n");
-          }
-        });
-      }
-    };
-    return {
-      TSTupleType: checkNode,
-      ArrayExpression: checkNode
-    };
-  }
-});
-
-const RULE_NAME$7 = "generic-spacing";
-const genericSpacing = createEslintRule({
-  name: RULE_NAME$7,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Spaces around generic type parameters",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      genericSpacingMismatch: "Generic spaces mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.getText();
-    return {
-      TSTypeParameterDeclaration: (node) => {
-        const params = node.params;
-        for (const param of params) {
-          const leftToken = sourceCode.getTokenBefore(param);
-          const rightToken = sourceCode.getTokenAfter(param);
-          const hasSpacingBeforeParam = sourceCode.isSpaceBetween(leftToken, param);
-          const hasSpacingAfterParam = sourceCode.isSpaceBetween(param, rightToken);
-          if (hasSpacingBeforeParam && param.loc.start.line === node.loc.start.line && leftToken.value === "<") {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: leftToken.loc.end.line,
-                  column: leftToken.loc.end.column
-                },
-                end: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column - 1
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
-              }
-            });
-          }
-          if (hasSpacingAfterParam && param.loc.end.line === node.loc.end.line) {
-            context.report({
-              loc: {
-                start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column
-                },
-                end: {
-                  line: rightToken.loc.start.line,
-                  column: rightToken.loc.start.column
-                }
-              },
-              node,
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
-              }
-            });
-          }
-          if (!hasSpacingBeforeParam && util__namespace.isCommaToken(leftToken)) {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: leftToken.loc.end.line,
-                  column: leftToken.loc.end.column
-                },
-                end: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column - 1
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([leftToken.range[1], param.range[0]], " ");
-              }
-            });
-          }
-        }
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression"].includes(node.parent.type)) {
-          const leftToken = sourceCode.getTokenBefore(node);
-          const hasSpacingBeforeNode = sourceCode.isSpaceBetween(leftToken, node);
-          const lastParam = params[params.length - 1];
-          const endBracket = sourceCode.getTokenAfter(lastParam);
-          const rightToken = sourceCode.getTokenAfter(endBracket, util__namespace.isOpeningParenToken);
-          if (!rightToken) {
-            return;
-          }
-          const hasSpacingAfterParam = sourceCode.isSpaceBetween(endBracket, rightToken);
-          if (hasSpacingBeforeNode && node.parent.type !== utils.AST_NODE_TYPES.TSFunctionType) {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: leftToken.loc.end.line,
-                  column: leftToken.loc.end.column
-                },
-                end: {
-                  line: node.loc.start.line,
-                  column: node.loc.start.column
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([leftToken.range[1], node.range[0]]);
-              }
-            });
-          }
-          if (hasSpacingAfterParam && [utils.AST_NODE_TYPES.TSFunctionType, utils.AST_NODE_TYPES.FunctionDeclaration, utils.AST_NODE_TYPES.FunctionExpression].includes(node.parent.type)) {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: endBracket.loc.end.line,
-                  column: endBracket.loc.end.column
-                },
-                end: {
-                  line: rightToken.loc.start.line,
-                  column: rightToken.loc.start.column
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([endBracket.range[1], rightToken.range[0]]);
-              }
-            });
-          }
-        }
-      },
-      // add space around = in type Foo<T = true>
-      TSTypeParameter: (node) => {
-        if (!node.default) {
-          return;
-        }
-        const endNode = node.constraint ?? node.name;
-        const from = endNode.range[1];
-        const to = node.default.range[0];
-        const spaceAndEqual = sourceCode.text.slice(from, to);
-        if (spaceAndEqual !== " = ") {
-          const preSpace = spaceAndEqual.match(/^(\s*)/)?.[0];
-          const postSpace = spaceAndEqual.match(/(\s*)$/)?.[0];
-          if (preSpace.length !== 1) {
-            context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([from, from + preSpace.length], " ");
-              },
-              loc: {
-                start: {
-                  line: node.loc.start.line,
-                  column: node.loc.start.column + 1
-                },
-                end: {
-                  line: node.loc.end.line,
-                  column: node.loc.end.column - 2 - postSpace.length
-                }
-              },
-              node,
-              messageId: "genericSpacingMismatch"
-            });
-          }
-          if (postSpace.length !== 1) {
-            context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([to - postSpace.length, to], " ");
-              },
-              loc: {
-                start: {
-                  line: node.loc.start.line,
-                  column: node.loc.start.column + 2 + preSpace.length
-                },
-                end: {
-                  line: node.loc.end.line,
-                  column: node.loc.end.column - 1
-                }
-              },
-              messageId: "genericSpacingMismatch"
-            });
-          }
-        }
-      },
-      // type T = Generic< any >
-      TSTypeParameterInstantiation: (node) => {
-        const params = node.params;
-        for (const param of params) {
-          const leftToken = sourceCode.getTokenBefore(param);
-          const rightToken = sourceCode.getTokenAfter(param);
-          const hasSpacingBeforeParam = leftToken.value === "<" ? sourceCode.isSpaceBetween(leftToken, param) : false;
-          const hasSpacingAfterParam = rightToken.value === ">" ? sourceCode.isSpaceBetween(param, rightToken) : false;
-          if (hasSpacingBeforeParam && leftToken.loc.end.line === param.loc.start.line) {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: leftToken.loc.end.line,
-                  column: leftToken.loc.end.column
-                },
-                end: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
-              }
-            });
-          }
-          if (hasSpacingAfterParam && param.loc.end.line === rightToken.loc.start.line) {
-            context.report({
-              node,
-              loc: {
-                start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column
-                },
-                end: {
-                  line: rightToken.loc.start.line,
-                  column: rightToken.loc.start.column
-                }
-              },
-              messageId: "genericSpacingMismatch",
-              *fix(fixer) {
-                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
-              }
-            });
-          }
-        }
-      },
-      // Add spaces before extends
-      // interface a {}
-      // interface A<B extends 1>extends a {}
-      // Fix to: interface A<B extends 1> extends a {}
-      TSInterfaceDeclaration: (node) => {
-        if (!node.extends || !node.typeParameters) {
-          return;
-        }
-        const { typeParameters } = node;
-        const extendsKeywordStart = typeParameters.range[1];
-        const extendsKeywordEnd = node.extends[0].range[0];
-        const extendsText = text.slice(extendsKeywordStart, extendsKeywordEnd);
-        if (!/^\s+/.test(extendsText)) {
-          context.report({
-            loc: {
-              start: {
-                line: typeParameters.loc.end.line,
-                column: typeParameters.loc.end.column
-              },
-              end: {
-                line: typeParameters.loc.end.line,
-                column: typeParameters.loc.end.column + 7
-              }
-            },
-            node,
-            messageId: "genericSpacingMismatch",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([extendsKeywordStart, extendsKeywordEnd - 8], " ");
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$6 = "import-dedupe";
+const RULE_NAME$1 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$1,
   meta: {
     type: "problem",
     docs: {
@@ -411,9 +54,9 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$5 = "no-inline-type-import";
+const RULE_NAME = "no-inline-type-import";
 const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME,
   meta: {
     type: "layout",
     docs: {
@@ -463,469 +106,10 @@ import { ${valueSpecifiersText} } from "${node.source.value}";`
   }
 });
 
-const RULE_NAME$4 = "no-space-before-paren";
-const noSpaceBeforeParen = createEslintRule({
-  name: RULE_NAME$4,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Space before paren",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noSpaceBeforeParen: "Expected no space before paren"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.getText();
-    return {
-      ImportExpression(node) {
-        const sourceRange = node.source.range;
-        const parenStart = sourceRange[0] - 1;
-        const importEnd = node.range[0] + 6;
-        const textBetweenImportAndParenRange = [importEnd, parenStart];
-        const textBetweenImportAndParen = text.slice(...textBetweenImportAndParenRange);
-        if (textBetweenImportAndParen.length > 0) {
-          context.report({
-            node,
-            messageId: "noSpaceBeforeParen",
-            *fix(fixer) {
-              yield fixer.removeRange(textBetweenImportAndParenRange);
-            }
-          });
-        }
-      },
-      CallExpression(node) {
-        let caller = "property" in node.callee ? node.callee.property : node.callee;
-        if (caller.type === utils.AST_NODE_TYPES.TSInstantiationExpression && "property" in caller.expression) {
-          caller = caller.expression.property;
-        }
-        const callerEnd = reactivity.ref(caller.range[1]);
-        const textAfterCaller = reactivity.computed(() => text.slice(callerEnd.value));
-        const parenStart = reactivity.ref(callerEnd.value + textAfterCaller.value.indexOf("("));
-        const textBetweenFunctionNameAndParenRange = reactivity.computed(
-          () => [callerEnd.value, parenStart.value]
-        );
-        const textBetweenFunctionNameAndParen = reactivity.computed(
-          () => text.slice(...textBetweenFunctionNameAndParenRange.value)
-        );
-        const hasGenerics = reactivity.computed(() => /^\s*</.test(textBetweenFunctionNameAndParen.value));
-        const hasIndex = reactivity.computed(() => textBetweenFunctionNameAndParen.value.startsWith("]"));
-        if (hasIndex.value) {
-          callerEnd.value += 1;
-        }
-        if (node.optional) {
-          parenStart.value = callerEnd.value + textAfterCaller.value.indexOf("(");
-        }
-        const spaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
-        if (!hasGenerics.value) {
-          if (spaces.length > 0 && textBetweenFunctionNameAndParen.value !== "?.") {
-            const textBeforeSpaces = textBetweenFunctionNameAndParen.value.slice(
-              0,
-              textBetweenFunctionNameAndParen.value.length - spaces.length
-            );
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.replaceTextRange(
-                  textBetweenFunctionNameAndParenRange.value,
-                  textBeforeSpaces + (node.optional ? "?." : "")
-                );
-              }
-            });
-          }
-        } else {
-          const preSpaces = /^(\s*)/.exec(textBetweenFunctionNameAndParen.value)[1];
-          const postSpaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
-          const spacesBeforeOptionalMark = /(\s*)\?\./.exec(textBetweenFunctionNameAndParen.value)?.[1] ?? "";
-          if (preSpaces.length > 0) {
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.removeRange([callerEnd.value, callerEnd.value + preSpaces.length]);
-              }
-            });
-          }
-          if (postSpaces.length > 0) {
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.removeRange([parenStart.value - postSpaces.length, parenStart.value]);
-              }
-            });
-          }
-          if (spacesBeforeOptionalMark.length > 0 && !textBetweenFunctionNameAndParen.value.endsWith(" ")) {
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.removeRange([parenStart.value - spacesBeforeOptionalMark.length - 2, parenStart.value - 2]);
-              }
-            });
-          }
-        }
-      },
-      NewExpression(node) {
-        const calleeEnd = node.callee.range[1];
-        const textAfterCallee = text.slice(calleeEnd);
-        const parenStart = calleeEnd + textAfterCallee.indexOf("(");
-        const textBetweenCalleeAndParenRange = [calleeEnd, parenStart];
-        const textBetweenCalleeAndParen = text.slice(...textBetweenCalleeAndParenRange);
-        const hasGenerics = /^\s*</.test(textBetweenCalleeAndParen);
-        if (!hasGenerics && textBetweenCalleeAndParen.length > 0) {
-          context.report({
-            node,
-            messageId: "noSpaceBeforeParen",
-            *fix(fixer) {
-              yield fixer.removeRange(textBetweenCalleeAndParenRange);
-            }
-          });
-        } else if (hasGenerics) {
-          const preSpaces = /^(\s*)/.exec(textBetweenCalleeAndParen)[1];
-          const postSpaces = /(\s*)$/.exec(textBetweenCalleeAndParen)[1];
-          if (preSpaces.length > 0) {
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.removeRange([calleeEnd, calleeEnd + preSpaces.length]);
-              }
-            });
-          }
-          if (postSpaces.length > 0) {
-            context.report({
-              node,
-              messageId: "noSpaceBeforeParen",
-              *fix(fixer) {
-                yield fixer.removeRange([parenStart - postSpaces.length, parenStart]);
-              }
-            });
-          }
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$3 = "semi-spacing";
-const semiSpacing = createEslintRule({
-  name: RULE_NAME$3,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Semicolon spacing in types",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noSpaceBeforeSemi: "Expected no space before semicolon"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      TSTypeAliasDeclaration(node) {
-        const leftToken = node.typeAnnotation;
-        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
-        if (!rightToken || rightToken.type !== utils.AST_TOKEN_TYPES.Punctuator || rightToken.value !== ";") {
-          return;
-        }
-        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
-        if (hasSpacing) {
-          context.report({
-            loc: {
-              start: {
-                line: leftToken.loc.end.line,
-                column: leftToken.loc.end.column
-              },
-              end: {
-                line: rightToken.loc.start.line,
-                column: rightToken.loc.start.column
-              }
-            },
-            node,
-            messageId: "noSpaceBeforeSemi",
-            *fix(fixer) {
-              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$2 = "space-before-function-paren";
-const spaceBeforeFunctionParen = createEslintRule({
-  name: RULE_NAME$2,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Enforce consistent spacing before function parenthesis",
-      recommended: false,
-      extendsBaseRule: true
-    },
-    fixable: "whitespace",
-    schema: [
-      {
-        oneOf: [
-          {
-            enum: ["always", "never"]
-          },
-          {
-            type: "object",
-            properties: {
-              anonymous: {
-                enum: ["always", "never", "ignore"]
-              },
-              named: {
-                enum: ["always", "never", "ignore"]
-              },
-              asyncArrow: {
-                enum: ["always", "never", "ignore"]
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      }
-    ],
-    messages: {
-      unexpected: "Unexpected space before function parentheses.",
-      missing: "Missing space before function parentheses."
-    }
-  },
-  defaultOptions: ["always"],
-  create(context, [firstOption]) {
-    const sourceCode = context.getSourceCode();
-    const baseConfig = typeof firstOption === "string" ? firstOption : "always";
-    const overrideConfig = typeof firstOption === "object" ? firstOption : {};
-    function isNamedFunction(node) {
-      if (node.id != null) {
-        return true;
-      }
-      const parent = node.parent;
-      return parent.type === utils.AST_NODE_TYPES.MethodDefinition || parent.type === utils.AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === utils.AST_NODE_TYPES.Property && (parent.kind === "get" || parent.kind === "set" || parent.method);
-    }
-    function getConfigForFunction(node) {
-      if (node.type === utils.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.async && util__namespace.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
-          return overrideConfig.asyncArrow ?? baseConfig;
-        }
-      } else if (isNamedFunction(node)) {
-        return overrideConfig.named ?? baseConfig;
-      } else if (!node.generator) {
-        return overrideConfig.anonymous ?? baseConfig;
-      }
-      return "ignore";
-    }
-    function checkFunction(node) {
-      const functionConfig = getConfigForFunction(node);
-      if (functionConfig === "ignore") {
-        return;
-      }
-      let leftToken, rightToken;
-      if (node.typeParameters) {
-        leftToken = sourceCode.getLastToken(node.typeParameters);
-        rightToken = sourceCode.getTokenAfter(leftToken);
-      } else {
-        rightToken = sourceCode.getFirstToken(node, util__namespace.isOpeningParenToken);
-        leftToken = sourceCode.getTokenBefore(rightToken);
-      }
-      const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
-      if (hasSpacing && functionConfig === "never") {
-        context.report({
-          node,
-          loc: {
-            start: leftToken.loc.end,
-            end: rightToken.loc.start
-          },
-          messageId: "unexpected",
-          fix: (fixer) => fixer.removeRange([leftToken.range[1], rightToken.range[0]])
-        });
-      } else if (!hasSpacing && functionConfig === "always" && !node.typeParameters) {
-        context.report({
-          node,
-          loc: rightToken.loc,
-          messageId: "missing",
-          fix: (fixer) => fixer.insertTextAfter(leftToken, " ")
-        });
-      }
-    }
-    return {
-      ArrowFunctionExpression: checkFunction,
-      FunctionDeclaration: checkFunction,
-      FunctionExpression: checkFunction,
-      TSEmptyBodyFunctionExpression: checkFunction,
-      TSDeclareFunction: checkFunction
-    };
-  }
-});
-
-const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
-const RULE_NAME$1 = "space-between-generic-and-paren";
-const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Spaces between generic type parameters and paren",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.text;
-    return {
-      TSTypeParameter: (node) => {
-        const spaceStartRange = node.range[1] + 1;
-        const post = text.slice(spaceStartRange);
-        const postSpace = post.match(/^(\s*)/)?.[0];
-        const postEqual = post.slice(postSpace.length).match(/^(=)/)?.[0];
-        const postComma = text.slice(node.range[1]).match(/^(,)/)?.[0];
-        const postQuestionMark = text.slice(spaceStartRange + postSpace.length).match(/^(\?)/)?.[0];
-        const postOperatorOrAnyBracketOrKeyword = text.slice(spaceStartRange + postSpace.length).match(operatorOrAnyBracketOrKeywordRE)?.[0];
-        if (postSpace?.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== utils.AST_NODE_TYPES.TSInferType) {
-          context.report({
-            loc: {
-              start: {
-                line: node.loc.end.line,
-                column: node.loc.end.column + 1
-              },
-              end: {
-                line: node.loc.end.line,
-                column: node.loc.end.column + 1 + postSpace.length
-              }
-            },
-            node,
-            messageId: "noSpaceBetweenGenericAndParen",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
-            }
-          });
-        }
-        if (node.parent?.parent.type === utils.AST_NODE_TYPES.FunctionDeclaration) {
-          const spaceEndRange = node.range[0] - 1;
-          const pre = sourceCode.text.slice(0, spaceEndRange);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          if (preSpace?.length) {
-            context.report({
-              loc: {
-                start: {
-                  line: node.loc.start.line,
-                  column: node.loc.start.column - preSpace.length
-                },
-                end: {
-                  line: node.loc.start.line,
-                  column: node.loc.start.column - 1
-                }
-              },
-              node,
-              messageId: "noSpaceBetweenGenericAndParen",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
-              }
-            });
-          }
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "space-in-empty-block";
-const spaceInEmptyBlock = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Disallow spaces in empty block",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noSpaceInEmptyBlock: "Expected no space in empty block"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    return {
-      BlockStatement: (node) => {
-        if (node.body.length || sourceCode.getCommentsInside(node).length) {
-          return;
-        }
-        const spaceStartRange = node.range[1] - 2;
-        const post = sourceCode.text.slice(spaceStartRange);
-        const postSpace = post.match(/^(\s*)/)?.[0];
-        if (postSpace?.length) {
-          context.report({
-            loc: {
-              start: node.loc.start,
-              end: {
-                line: node.loc.end.line,
-                column: node.loc.end.column - 1 + postSpace.length
-              }
-            },
-            messageId: "noSpaceInEmptyBlock",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([node.range[0] + 1, spaceStartRange + postSpace.length], "");
-            }
-          });
-        }
-        const spaceEndRange = node.range[0] + 1;
-        const pre = sourceCode.text.slice(0, spaceEndRange);
-        const preSpace = pre.match(/(\s+)$/)?.[0];
-        if (preSpace?.length) {
-          context.report({
-            loc: {
-              start: {
-                line: node.loc.start.line,
-                column: node.loc.start.column - preSpace.length
-              },
-              end: {
-                line: node.loc.start.line,
-                column: node.loc.start.column
-              }
-            },
-            messageId: "noSpaceInEmptyBlock",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
 const index = {
   rules: {
     "import-dedupe": importDedupe,
-    "generic-spacing": genericSpacing,
-    "space-between-generic-and-paren": spaceBetweenGenericAndParen,
-    "space-in-empty-block": spaceInEmptyBlock,
-    "semi-spacing": semiSpacing,
-    "no-inline-type-import": noInlineTypeImport,
-    "no-space-before-paren": noSpaceBeforeParen,
-    "space-before-function-paren": spaceBeforeFunctionParen,
-    "array-bracket-spacing": arrayBracketSpacing
+    "no-inline-type-import": noInlineTypeImport
   }
 };