@so1ve/eslint-plugin 0.43.1 → 0.44.0

package/dist/index.cjs

@@ -2,12 +2,26 @@
 
 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$6 = "generic-spacing";
+const RULE_NAME$7 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$6,
+  name: RULE_NAME$7,
   meta: {
     type: "layout",
     docs: {
@@ -255,9 +269,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 +320,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: {
@@ -382,9 +396,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: {
@@ -483,9 +497,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 +564,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.isSpaceBetweenTokens(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,
@@ -656,7 +777,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 } from '@typescript-eslint/utils';
 import { ref, computed } from '@vue/reactivity';
+import * as util from '@typescript-eslint/utils/dist/ast-utils';
 
 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: {
@@ -253,9 +254,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 +305,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: {
@@ -380,9 +381,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: {
@@ -481,9 +482,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 +549,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.isSpaceBetweenTokens(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,
@@ -654,7 +762,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.44.0",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {