@so1ve/eslint-plugin 0.36.1 → 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;
@@ -37,12 +38,12 @@ const genericSpacing = createEslintRule({
               node,
               loc: {
                 start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column - 1 - preSpace.length
+                  line: param.loc.start.line,
+                  column: param.loc.start.column + 1 - preSpace.length
                 },
                 end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column - 1
+                  line: param.loc.start.line,
+                  column: param.loc.start.column - 1
                 }
               },
               messageId: "genericSpacingMismatch",
@@ -165,14 +166,91 @@ const genericSpacing = createEslintRule({
             });
           }
         }
+      },
+      TSTypeParameterInstantiation: (node) => {
+        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) {
+            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]], "");
+              }
+            });
+          }
+          if (postSpace && postSpace.length) {
+            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], "");
+              }
+            });
+          }
+        }
+      },
+      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$4 = "import-dedupe";
+const RULE_NAME$5 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -220,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"
@@ -296,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"
@@ -316,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;
@@ -363,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"
@@ -412,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"
@@ -461,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,
@@ -468,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;
@@ -35,12 +36,12 @@ const genericSpacing = createEslintRule({
               node,
               loc: {
                 start: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column - 1 - preSpace.length
+                  line: param.loc.start.line,
+                  column: param.loc.start.column + 1 - preSpace.length
                 },
                 end: {
-                  line: param.loc.end.line,
-                  column: param.loc.end.column - 1
+                  line: param.loc.start.line,
+                  column: param.loc.start.column - 1
                 }
               },
               messageId: "genericSpacingMismatch",
@@ -163,14 +164,91 @@ const genericSpacing = createEslintRule({
             });
           }
         }
+      },
+      TSTypeParameterInstantiation: (node) => {
+        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) {
+            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]], "");
+              }
+            });
+          }
+          if (postSpace && postSpace.length) {
+            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], "");
+              }
+            });
+          }
+        }
+      },
+      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$4 = "import-dedupe";
+const RULE_NAME$5 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$5,
   meta: {
     type: "problem",
     docs: {
@@ -218,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"
@@ -294,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"
@@ -314,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;
@@ -361,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"
@@ -410,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"
@@ -459,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,
@@ -466,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.36.1",
+  "version": "0.37.1",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {