@so1ve/eslint-plugin 0.43.1 → 0.45.0

package/dist/index.cjs

@@ -1,13 +1,27 @@
 'use strict';
 
 const utils = require('@typescript-eslint/utils');
+const util = require('@typescript-eslint/utils/dist/ast-utils');
 const reactivity = require('@vue/reactivity');
 
+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$6 = "generic-spacing";
+const RULE_NAME$7 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$7,
   meta: {
     type: "layout",
     docs: {
@@ -29,18 +43,17 @@ const genericSpacing = createEslintRule({
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
           const param = params[i];
-          const pre = sourceCode.text.slice(0, param.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const preComma = pre.match(/(,)\s+$/)?.[0];
-          const post = sourceCode.text.slice(param.range[1]);
-          const postSpace = post.match(/^(\s*)/)?.[0];
-          if (preSpace && preSpace.length && !preComma && param.loc.start.line === node.loc.start.line) {
+          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: param.loc.start.line,
-                  column: param.loc.start.column + 1 - preSpace.length
+                  line: leftToken.loc.end.line,
+                  column: leftToken.loc.end.column
                 },
                 end: {
                   line: param.loc.start.line,
@@ -49,11 +62,11 @@ const genericSpacing = createEslintRule({
               },
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.removeRange([param.range[0] - preSpace.length, param.range[0]]);
+                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
               }
             });
           }
-          if (postSpace && postSpace.length && param.loc.end.line === node.loc.end.line) {
+          if (hasSpacingAfterParam && param.loc.end.line === node.loc.end.line) {
             context.report({
               loc: {
                 start: {
@@ -61,59 +74,60 @@ const genericSpacing = createEslintRule({
                   column: param.loc.end.column
                 },
                 end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column + postSpace.length
+                  line: rightToken.loc.start.line,
+                  column: rightToken.loc.start.column
                 }
               },
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
               }
             });
           }
-        }
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression"].includes(node.parent.type)) {
-          const pre = sourceCode.text.slice(0, node.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const post = sourceCode.text.slice(node.range[1]);
-          const postBracket = post.match(/^(\s*)\(/)?.[0];
-          if (preSpace && preSpace.length && !postBracket) {
+          if (!hasSpacingBeforeParam && 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([node.range[0] - preSpace.length, node.range[0]]);
+                yield fixer.replaceTextRange([leftToken.range[1], param.range[0]], " ");
               }
             });
           }
-          if (postBracket && postBracket.length > 1) {
+        }
+        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);
+          const hasSpacingAfterParam = sourceCode.isSpaceBetween(endBracket, rightToken);
+          if (hasSpacingBeforeNode && node.parent.type !== utils.AST_NODE_TYPES.TSFunctionType) {
             context.report({
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.removeRange([node.range[1], node.range[1] + postBracket.length - 1]);
+                yield fixer.removeRange([leftToken.range[1], node.range[0]]);
               }
             });
           }
-        }
-        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/)) {
+          if (hasSpacingAfterParam && node.parent.type === utils.AST_NODE_TYPES.TSFunctionType) {
             context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([from, to], ", ");
-              },
-              loc: {
-                start: prev.loc.end,
-                end: current.loc.start
-              },
+              node,
               messageId: "genericSpacingMismatch",
-              node
+              *fix(fixer) {
+                yield fixer.removeRange([endBracket.range[1], rightToken.range[0]]);
+              }
             });
           }
         }
@@ -174,46 +188,25 @@ const genericSpacing = createEslintRule({
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
           const param = params[i];
-          const pre = sourceCode.text.slice(0, param.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const preComma = pre.match(/(,)\s+$/)?.[0];
-          const post = sourceCode.text.slice(param.range[1]);
-          const postSpace = post.match(/^(\s*)/)?.[0];
-          if (preSpace && preSpace.length && !preComma && param.loc.start.line === node.loc.start.line) {
+          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) {
             context.report({
               node,
-              loc: {
-                start: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column + 1 - preSpace.length
-                },
-                end: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column - 1
-                }
-              },
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[0] - preSpace.length, param.range[0]], "");
+                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
               }
             });
           }
-          if (postSpace && postSpace.length && param.loc.end.line === node.loc.end.line) {
+          if (hasSpacingAfterParam) {
             context.report({
-              loc: {
-                start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column
-                },
-                end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column + postSpace.length
-                }
-              },
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
               }
             });
           }
@@ -255,9 +248,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$5 = "import-dedupe";
+const RULE_NAME$6 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
     type: "problem",
     docs: {
@@ -306,9 +299,9 @@ const importDedupe = createEslintRule({
 });
 
 const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
-const RULE_NAME$4 = "space-between-generic-and-paren";
+const RULE_NAME$5 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
@@ -334,7 +327,7 @@ const spaceBetweenGenericAndParen = createEslintRule({
         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 && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== "TSInferType") {
+        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== utils.AST_NODE_TYPES.TSInferType) {
           context.report({
             loc: {
               start: {
@@ -353,7 +346,7 @@ const spaceBetweenGenericAndParen = createEslintRule({
             }
           });
         }
-        if (node.parent?.parent.type === "FunctionDeclaration") {
+        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];
@@ -382,9 +375,9 @@ const spaceBetweenGenericAndParen = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "no-spaces-before-paren";
+const RULE_NAME$4 = "no-spaces-before-paren";
 const noSpacesBeforeParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$4,
   meta: {
     type: "layout",
     docs: {
@@ -420,7 +413,7 @@ const noSpacesBeforeParen = createEslintRule({
       },
       CallExpression(node) {
         let caller = "property" in node.callee ? node.callee.property : node.callee;
-        if (caller.type === "TSInstantiationExpression" && "property" in caller.expression) {
+        if (caller.type === utils.AST_NODE_TYPES.TSInstantiationExpression && "property" in caller.expression) {
           caller = caller.expression.property;
         }
         const callerEnd = reactivity.ref(caller.range[1]);
@@ -483,9 +476,9 @@ const noSpacesBeforeParen = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "space-in-empty-block";
+const RULE_NAME$3 = "space-in-empty-block";
 const spaceInEmptyBlock = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$3,
   meta: {
     type: "layout",
     docs: {
@@ -550,6 +543,113 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
+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 RULE_NAME$1 = "semi-spacing";
 const semiSpacing = createEslintRule({
   name: RULE_NAME$1,
@@ -568,29 +668,30 @@ const semiSpacing = createEslintRule({
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    const text = sourceCode.text;
     return {
       TSTypeAliasDeclaration(node) {
-        const sourceLine = text.slice(node.range[0], node.range[1]);
-        const preSemiSpace = sourceLine.match(/(\s+);$/)?.[0];
-        if (preSemiSpace) {
-          const spaceStart = node.range[0] + sourceLine.length - preSemiSpace.length;
-          const spaceEnd = node.range[0] + sourceLine.length - 1;
+        const leftToken = node.typeAnnotation;
+        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
+        if (rightToken.type !== utils.AST_TOKEN_TYPES.Punctuator) {
+          return;
+        }
+        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
+        if (hasSpacing) {
           context.report({
             loc: {
               start: {
-                line: node.loc.start.line,
-                column: node.loc.start.column + sourceLine.length - preSemiSpace.length
+                line: leftToken.loc.end.line,
+                column: leftToken.loc.end.column
               },
               end: {
-                line: node.loc.start.line,
-                column: node.loc.start.column + sourceLine.length - 1
+                line: rightToken.loc.start.line,
+                column: rightToken.loc.start.column
               }
             },
             node,
             messageId: "noSpaceBeforeSemi",
             *fix(fixer) {
-              yield fixer.removeRange([spaceStart, spaceEnd]);
+              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
             }
           });
         }
@@ -656,7 +757,8 @@ const index = {
     "space-in-empty-block": spaceInEmptyBlock,
     "semi-spacing": semiSpacing,
     "no-inline-type-import": noInlineTypeImport,
-    "no-spaces-before-paren": noSpacesBeforeParen
+    "no-spaces-before-paren": noSpacesBeforeParen,
+    "space-before-function-paren": spaceBeforeFunctionParen
   }
 };
 

package/dist/index.d.ts

@@ -1,5 +1,16 @@
 import * as _typescript_eslint_utils_dist_ts_eslint_Rule from '@typescript-eslint/utils/dist/ts-eslint/Rule';
 
+type Option = "never" | "always";
+type FuncOption = Option | "ignore";
+type Options = [
+    Option | {
+        anonymous?: FuncOption;
+        named?: FuncOption;
+        asyncArrow?: FuncOption;
+    }
+];
+type MessageIds = "unexpected" | "missing";
+
 declare const _default: {
     rules: {
         "import-dedupe": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"importDedupe", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
@@ -9,6 +20,7 @@ declare const _default: {
         "semi-spacing": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noSpaceBeforeSemi", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "no-inline-type-import": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noInlineTypeImport", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "no-spaces-before-paren": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noSpacesBeforeParen", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
+        "space-before-function-paren": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<MessageIds, Options, _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
     };
 };
 

package/dist/index.mjs

@@ -1,11 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+import * as util from '@typescript-eslint/utils/dist/ast-utils';
 import { ref, computed } from '@vue/reactivity';
 
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$6 = "generic-spacing";
+const RULE_NAME$7 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$7,
   meta: {
     type: "layout",
     docs: {
@@ -27,18 +28,17 @@ const genericSpacing = createEslintRule({
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
           const param = params[i];
-          const pre = sourceCode.text.slice(0, param.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const preComma = pre.match(/(,)\s+$/)?.[0];
-          const post = sourceCode.text.slice(param.range[1]);
-          const postSpace = post.match(/^(\s*)/)?.[0];
-          if (preSpace && preSpace.length && !preComma && param.loc.start.line === node.loc.start.line) {
+          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: param.loc.start.line,
-                  column: param.loc.start.column + 1 - preSpace.length
+                  line: leftToken.loc.end.line,
+                  column: leftToken.loc.end.column
                 },
                 end: {
                   line: param.loc.start.line,
@@ -47,11 +47,11 @@ const genericSpacing = createEslintRule({
               },
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.removeRange([param.range[0] - preSpace.length, param.range[0]]);
+                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
               }
             });
           }
-          if (postSpace && postSpace.length && param.loc.end.line === node.loc.end.line) {
+          if (hasSpacingAfterParam && param.loc.end.line === node.loc.end.line) {
             context.report({
               loc: {
                 start: {
@@ -59,59 +59,60 @@ const genericSpacing = createEslintRule({
                   column: param.loc.end.column
                 },
                 end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column + postSpace.length
+                  line: rightToken.loc.start.line,
+                  column: rightToken.loc.start.column
                 }
               },
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
               }
             });
           }
-        }
-        if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression"].includes(node.parent.type)) {
-          const pre = sourceCode.text.slice(0, node.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const post = sourceCode.text.slice(node.range[1]);
-          const postBracket = post.match(/^(\s*)\(/)?.[0];
-          if (preSpace && preSpace.length && !postBracket) {
+          if (!hasSpacingBeforeParam && 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([node.range[0] - preSpace.length, node.range[0]]);
+                yield fixer.replaceTextRange([leftToken.range[1], param.range[0]], " ");
               }
             });
           }
-          if (postBracket && postBracket.length > 1) {
+        }
+        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.isOpeningParenToken);
+          const hasSpacingAfterParam = sourceCode.isSpaceBetween(endBracket, rightToken);
+          if (hasSpacingBeforeNode && node.parent.type !== AST_NODE_TYPES.TSFunctionType) {
             context.report({
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.removeRange([node.range[1], node.range[1] + postBracket.length - 1]);
+                yield fixer.removeRange([leftToken.range[1], node.range[0]]);
               }
             });
           }
-        }
-        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/)) {
+          if (hasSpacingAfterParam && node.parent.type === AST_NODE_TYPES.TSFunctionType) {
             context.report({
-              *fix(fixer) {
-                yield fixer.replaceTextRange([from, to], ", ");
-              },
-              loc: {
-                start: prev.loc.end,
-                end: current.loc.start
-              },
+              node,
               messageId: "genericSpacingMismatch",
-              node
+              *fix(fixer) {
+                yield fixer.removeRange([endBracket.range[1], rightToken.range[0]]);
+              }
             });
           }
         }
@@ -172,46 +173,25 @@ const genericSpacing = createEslintRule({
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
           const param = params[i];
-          const pre = sourceCode.text.slice(0, param.range[0]);
-          const preSpace = pre.match(/(\s+)$/)?.[0];
-          const preComma = pre.match(/(,)\s+$/)?.[0];
-          const post = sourceCode.text.slice(param.range[1]);
-          const postSpace = post.match(/^(\s*)/)?.[0];
-          if (preSpace && preSpace.length && !preComma && param.loc.start.line === node.loc.start.line) {
+          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) {
             context.report({
               node,
-              loc: {
-                start: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column + 1 - preSpace.length
-                },
-                end: {
-                  line: param.loc.start.line,
-                  column: param.loc.start.column - 1
-                }
-              },
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[0] - preSpace.length, param.range[0]], "");
+                yield fixer.removeRange([leftToken.range[1], param.range[0]]);
               }
             });
           }
-          if (postSpace && postSpace.length && param.loc.end.line === node.loc.end.line) {
+          if (hasSpacingAfterParam) {
             context.report({
-              loc: {
-                start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column
-                },
-                end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column + postSpace.length
-                }
-              },
               node,
               messageId: "genericSpacingMismatch",
               *fix(fixer) {
-                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+                yield fixer.removeRange([param.range[1], rightToken.range[0]]);
               }
             });
           }
@@ -253,9 +233,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$5 = "import-dedupe";
+const RULE_NAME$6 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
     type: "problem",
     docs: {
@@ -304,9 +284,9 @@ const importDedupe = createEslintRule({
 });
 
 const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
-const RULE_NAME$4 = "space-between-generic-and-paren";
+const RULE_NAME$5 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
@@ -332,7 +312,7 @@ const spaceBetweenGenericAndParen = createEslintRule({
         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 && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== "TSInferType") {
+        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== AST_NODE_TYPES.TSInferType) {
           context.report({
             loc: {
               start: {
@@ -351,7 +331,7 @@ const spaceBetweenGenericAndParen = createEslintRule({
             }
           });
         }
-        if (node.parent?.parent.type === "FunctionDeclaration") {
+        if (node.parent?.parent.type === AST_NODE_TYPES.FunctionDeclaration) {
           const spaceEndRange = node.range[0] - 1;
           const pre = sourceCode.text.slice(0, spaceEndRange);
           const preSpace = pre.match(/(\s+)$/)?.[0];
@@ -380,9 +360,9 @@ const spaceBetweenGenericAndParen = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "no-spaces-before-paren";
+const RULE_NAME$4 = "no-spaces-before-paren";
 const noSpacesBeforeParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$4,
   meta: {
     type: "layout",
     docs: {
@@ -418,7 +398,7 @@ const noSpacesBeforeParen = createEslintRule({
       },
       CallExpression(node) {
         let caller = "property" in node.callee ? node.callee.property : node.callee;
-        if (caller.type === "TSInstantiationExpression" && "property" in caller.expression) {
+        if (caller.type === AST_NODE_TYPES.TSInstantiationExpression && "property" in caller.expression) {
           caller = caller.expression.property;
         }
         const callerEnd = ref(caller.range[1]);
@@ -481,9 +461,9 @@ const noSpacesBeforeParen = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "space-in-empty-block";
+const RULE_NAME$3 = "space-in-empty-block";
 const spaceInEmptyBlock = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$3,
   meta: {
     type: "layout",
     docs: {
@@ -548,6 +528,113 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
+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 === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === AST_NODE_TYPES.Property && (parent.kind === "get" || parent.kind === "set" || parent.method);
+    }
+    function getConfigForFunction(node) {
+      if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.async && util.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.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 RULE_NAME$1 = "semi-spacing";
 const semiSpacing = createEslintRule({
   name: RULE_NAME$1,
@@ -566,29 +653,30 @@ const semiSpacing = createEslintRule({
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    const text = sourceCode.text;
     return {
       TSTypeAliasDeclaration(node) {
-        const sourceLine = text.slice(node.range[0], node.range[1]);
-        const preSemiSpace = sourceLine.match(/(\s+);$/)?.[0];
-        if (preSemiSpace) {
-          const spaceStart = node.range[0] + sourceLine.length - preSemiSpace.length;
-          const spaceEnd = node.range[0] + sourceLine.length - 1;
+        const leftToken = node.typeAnnotation;
+        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
+        if (rightToken.type !== AST_TOKEN_TYPES.Punctuator) {
+          return;
+        }
+        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
+        if (hasSpacing) {
           context.report({
             loc: {
               start: {
-                line: node.loc.start.line,
-                column: node.loc.start.column + sourceLine.length - preSemiSpace.length
+                line: leftToken.loc.end.line,
+                column: leftToken.loc.end.column
               },
               end: {
-                line: node.loc.start.line,
-                column: node.loc.start.column + sourceLine.length - 1
+                line: rightToken.loc.start.line,
+                column: rightToken.loc.start.column
               }
             },
             node,
             messageId: "noSpaceBeforeSemi",
             *fix(fixer) {
-              yield fixer.removeRange([spaceStart, spaceEnd]);
+              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
             }
           });
         }
@@ -654,7 +742,8 @@ const index = {
     "space-in-empty-block": spaceInEmptyBlock,
     "semi-spacing": semiSpacing,
     "no-inline-type-import": noInlineTypeImport,
-    "no-spaces-before-paren": noSpacesBeforeParen
+    "no-spaces-before-paren": noSpacesBeforeParen,
+    "space-before-function-paren": spaceBeforeFunctionParen
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "0.43.1",
+  "version": "0.45.0",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {