@so1ve/eslint-plugin 0.43.0 → 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: {
@@ -118,6 +132,7 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // add space around = in type Foo<T = true>
       TSTypeParameter: (node) => {
         if (!node.default) {
           return;
@@ -168,6 +183,7 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // type T = Generic< any >
       TSTypeParameterInstantiation: (node) => {
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
@@ -217,6 +233,10 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // 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;
@@ -249,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: {
@@ -299,9 +319,10 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "space-between-generic-and-paren";
+const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
+const RULE_NAME$5 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
@@ -326,8 +347,8 @@ const spaceBetweenGenericAndParen = createEslintRule({
         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(/^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/)?.[0];
-        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword) {
+        const postOperatorOrAnyBracketOrKeyword = text.slice(spaceStartRange + postSpace.length).match(operatorOrAnyBracketOrKeywordRE)?.[0];
+        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== "TSInferType") {
           context.report({
             loc: {
               start: {
@@ -375,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: {
@@ -476,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: {
@@ -543,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,
@@ -649,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: {
@@ -116,6 +117,7 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // add space around = in type Foo<T = true>
       TSTypeParameter: (node) => {
         if (!node.default) {
           return;
@@ -166,6 +168,7 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // type T = Generic< any >
       TSTypeParameterInstantiation: (node) => {
         const params = node.params;
         for (let i = 0; i < params.length; i++) {
@@ -215,6 +218,10 @@ const genericSpacing = createEslintRule({
           }
         }
       },
+      // 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;
@@ -247,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: {
@@ -297,9 +304,10 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "space-between-generic-and-paren";
+const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
+const RULE_NAME$5 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
@@ -324,8 +332,8 @@ const spaceBetweenGenericAndParen = createEslintRule({
         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(/^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/)?.[0];
-        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword) {
+        const postOperatorOrAnyBracketOrKeyword = text.slice(spaceStartRange + postSpace.length).match(operatorOrAnyBracketOrKeywordRE)?.[0];
+        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== "TSInferType") {
           context.report({
             loc: {
               start: {
@@ -373,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: {
@@ -474,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: {
@@ -541,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,
@@ -647,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.0",
+  "version": "0.44.0",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {
@@ -31,14 +31,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^5.48.0",
+    "@typescript-eslint/utils": "^5.49.0",
     "@vue/reactivity": "^3.2.45",
-    "eslint-define-config": "^1.13.0"
+    "eslint-define-config": "^1.14.0"
   },
   "devDependencies": {
     "@types/node": "^18.11.18",
-    "unbuild": "^1.0.2",
-    "vitest": "^0.26.3"
+    "unbuild": "^1.1.1",
+    "vitest": "^0.28.3"
   },
   "scripts": {
     "build": "rimraf dist && unbuild",