@so1ve/eslint-plugin 0.37.0 → 0.37.1

package/dist/index.cjs

@@ -4,16 +4,16 @@ const utils = require('@typescript-eslint/utils');
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$5 = "generic-spacing";
+const RULE_NAME$6 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Spaces around generic type parameters",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       genericSpacingMismatch: "Generic spaces mismatch"
@@ -22,6 +22,7 @@ const genericSpacing = createEslintRule({
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
+    const text = sourceCode.getText();
     return {
       TSTypeParameterDeclaration: (node) => {
         const params = node.params;
@@ -219,7 +220,6 @@ const genericSpacing = createEslintRule({
         if (!node.extends || !node.typeParameters) {
           return;
         }
-        const text = sourceCode.getText();
         const { typeParameters } = node;
         const extendsKeywordStart = typeParameters.range[1];
         const extendsKeywordEnd = node.extends[0].range[0];
@@ -248,9 +248,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "import-dedupe";
+const RULE_NAME$5 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -298,16 +298,16 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "space-between-generic-and-paren";
+const RULE_NAME$4 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$4,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Spaces between generic type parameters and paren",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
@@ -374,16 +374,16 @@ const spaceBetweenGenericAndParen = 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: "suggestion",
+    type: "layout",
     docs: {
       description: "Disallow spaces in empty block",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceInEmptyBlock: "Expected no space in empty block"
@@ -394,7 +394,7 @@ const spaceInEmptyBlock = createEslintRule({
     const sourceCode = context.getSourceCode();
     return {
       BlockStatement: (node) => {
-        if (node.body.length) {
+        if (node.body.length || sourceCode.getCommentsInside(node).length) {
           return;
         }
         const spaceStartRange = node.range[1] - 2;
@@ -441,16 +441,16 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
-const RULE_NAME$1 = "semi-spacing";
+const RULE_NAME$2 = "semi-spacing";
 const semiSpacing = createEslintRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME$2,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Semicolon spacing",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceBeforeSemi: "Expected no space before semicolon"
@@ -490,11 +490,11 @@ const semiSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME = "no-inline-type-import";
+const RULE_NAME$1 = "no-inline-type-import";
 const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$1,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Disallow inline type import",
       recommended: "error"
@@ -539,6 +539,131 @@ import { ${valueSpecifiersText} } from "${node.source.value}";`);
   }
 });
 
+const RULE_NAME = "space-before-function-paren";
+const spaceBeforeFunctionParen = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Enforce consistent spacing before function parenthesis",
+      recommended: "error",
+      extendsBaseRule: true
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      spaceBeforeFunctionParenMismatch: "Space before function paren mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      FunctionDeclaration: (node) => {
+        console.log(node);
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      FunctionExpression: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      ArrowFunctionExpression: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      TSDeclareFunction: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      TSTypeReference: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "import-dedupe": importDedupe,
@@ -546,7 +671,8 @@ const index = {
     "space-between-generic-and-paren": spaceBetweenGenericAndParen,
     "space-in-empty-block": spaceInEmptyBlock,
     "semi-spacing": semiSpacing,
-    "no-inline-type-import": noInlineTypeImport
+    "no-inline-type-import": noInlineTypeImport,
+    "space-before-function-paren": spaceBeforeFunctionParen
   }
 };
 

package/dist/index.d.ts

@@ -8,6 +8,7 @@ declare const _default: {
         "space-in-empty-block": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noSpaceInEmptyBlock", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "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>;
+        "space-before-function-paren": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"spaceBeforeFunctionParenMismatch", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
     };
 };
 

package/dist/index.mjs

@@ -2,16 +2,16 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$5 = "generic-spacing";
+const RULE_NAME$6 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$6,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Spaces around generic type parameters",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       genericSpacingMismatch: "Generic spaces mismatch"
@@ -20,6 +20,7 @@ const genericSpacing = createEslintRule({
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
+    const text = sourceCode.getText();
     return {
       TSTypeParameterDeclaration: (node) => {
         const params = node.params;
@@ -217,7 +218,6 @@ const genericSpacing = createEslintRule({
         if (!node.extends || !node.typeParameters) {
           return;
         }
-        const text = sourceCode.getText();
         const { typeParameters } = node;
         const extendsKeywordStart = typeParameters.range[1];
         const extendsKeywordEnd = node.extends[0].range[0];
@@ -246,9 +246,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "import-dedupe";
+const RULE_NAME$5 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -296,16 +296,16 @@ const importDedupe = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "space-between-generic-and-paren";
+const RULE_NAME$4 = "space-between-generic-and-paren";
 const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$4,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Spaces between generic type parameters and paren",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
@@ -372,16 +372,16 @@ const spaceBetweenGenericAndParen = 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: "suggestion",
+    type: "layout",
     docs: {
       description: "Disallow spaces in empty block",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceInEmptyBlock: "Expected no space in empty block"
@@ -392,7 +392,7 @@ const spaceInEmptyBlock = createEslintRule({
     const sourceCode = context.getSourceCode();
     return {
       BlockStatement: (node) => {
-        if (node.body.length) {
+        if (node.body.length || sourceCode.getCommentsInside(node).length) {
           return;
         }
         const spaceStartRange = node.range[1] - 2;
@@ -439,16 +439,16 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
-const RULE_NAME$1 = "semi-spacing";
+const RULE_NAME$2 = "semi-spacing";
 const semiSpacing = createEslintRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME$2,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Semicolon spacing",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
       noSpaceBeforeSemi: "Expected no space before semicolon"
@@ -488,11 +488,11 @@ const semiSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME = "no-inline-type-import";
+const RULE_NAME$1 = "no-inline-type-import";
 const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$1,
   meta: {
-    type: "suggestion",
+    type: "layout",
     docs: {
       description: "Disallow inline type import",
       recommended: "error"
@@ -537,6 +537,131 @@ import { ${valueSpecifiersText} } from "${node.source.value}";`);
   }
 });
 
+const RULE_NAME = "space-before-function-paren";
+const spaceBeforeFunctionParen = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Enforce consistent spacing before function parenthesis",
+      recommended: "error",
+      extendsBaseRule: true
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      spaceBeforeFunctionParenMismatch: "Space before function paren mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      FunctionDeclaration: (node) => {
+        console.log(node);
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      FunctionExpression: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      ArrowFunctionExpression: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      TSDeclareFunction: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      },
+      TSTypeReference: (node) => {
+        const pre = sourceCode.text.slice(0, node.range[0]);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (!preSpace || !preSpace.length) {
+          context.report({
+            node,
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column + 1
+              }
+            },
+            messageId: "spaceBeforeFunctionParenMismatch",
+            *fix(fixer) {
+              yield fixer.insertTextBefore(node, " ");
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "import-dedupe": importDedupe,
@@ -544,7 +669,8 @@ const index = {
     "space-between-generic-and-paren": spaceBetweenGenericAndParen,
     "space-in-empty-block": spaceInEmptyBlock,
     "semi-spacing": semiSpacing,
-    "no-inline-type-import": noInlineTypeImport
+    "no-inline-type-import": noInlineTypeImport,
+    "space-before-function-paren": spaceBeforeFunctionParen
   }
 };
 

package/package.json

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