@so1ve/eslint-plugin 0.32.2 → 0.34.0

package/dist/index.cjs

@@ -4,9 +4,9 @@ const utils = require('@typescript-eslint/utils');
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$1 = "generic-spacing";
+const RULE_NAME$3 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME$3,
   meta: {
     type: "suggestion",
     docs: {
@@ -24,6 +24,32 @@ const genericSpacing = createEslintRule({
     const sourceCode = context.getSourceCode();
     return {
       TSTypeParameterDeclaration: (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 post = sourceCode.text.slice(param.range[1]);
+          const postSpace = post.match(/^(\s*)/)?.[0];
+          if (preSpace && preSpace.length) {
+            context.report({
+              node,
+              messageId: "genericSpacingMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([param.range[0] - preSpace.length, param.range[0]], "");
+              }
+            });
+          }
+          if (postSpace && postSpace.length) {
+            context.report({
+              node,
+              messageId: "genericSpacingMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+              }
+            });
+          }
+        }
         if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression"].includes(node.parent.type)) {
           const pre = sourceCode.text.slice(0, node.range[0]);
           const preSpace = pre.match(/(\s+)$/)?.[0];
@@ -48,7 +74,6 @@ const genericSpacing = createEslintRule({
             });
           }
         }
-        const params = node.params;
         for (let i = 1; i < params.length; i++) {
           const prev = params[i - 1];
           const current = params[i];
@@ -95,9 +120,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME = "import-dedupe";
+const RULE_NAME$2 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$2,
   meta: {
     type: "problem",
     docs: {
@@ -145,10 +170,151 @@ const importDedupe = createEslintRule({
   }
 });
 
+const RULE_NAME$1 = "space-between-generic-and-paren";
+const spaceBetweenGenericAndParen = createEslintRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Spaces between generic type parameters and paren",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      spaceBetweenGenericAndParenMismatch: "Space between generic and paren mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      TSTypeParameter: (node) => {
+        const spaceStartRange = node.range[1] + 1;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace && postSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1
+              },
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1 + postSpace.length
+              }
+            },
+            messageId: "spaceBetweenGenericAndParenMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+            }
+          });
+        }
+        if (node.parent?.parent.type === "FunctionDeclaration") {
+          const spaceEndRange = node.range[0] - 1;
+          const pre = sourceCode.text.slice(0, spaceEndRange);
+          const preSpace = pre.match(/(\s+)$/)?.[0];
+          if (preSpace && preSpace.length) {
+            context.report({
+              loc: {
+                start: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column - preSpace.length
+                },
+                end: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column - 1
+                }
+              },
+              messageId: "spaceBetweenGenericAndParenMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME = "space-in-empty-block";
+const spaceInEmptyBlock = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Spaces in empty block",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      spaceInEmptyBlockMismatch: "Space in empty block mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      BlockStatement: (node) => {
+        if (node.body.length) {
+          return;
+        }
+        const spaceStartRange = node.range[1] - 2;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace && postSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 2
+              },
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 2 + postSpace.length
+              }
+            },
+            messageId: "spaceInEmptyBlockMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+            }
+          });
+        }
+        const spaceEndRange = node.range[0] + 1;
+        const pre = sourceCode.text.slice(0, spaceEndRange);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (preSpace && preSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.start.line,
+                column: node.loc.start.column - preSpace.length
+              },
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column
+              }
+            },
+            messageId: "spaceInEmptyBlockMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "import-dedupe": importDedupe,
-    "generic-spacing": genericSpacing
+    "generic-spacing": genericSpacing,
+    "space-between-generic-and-paren": spaceBetweenGenericAndParen,
+    "space-in-empty-block": spaceInEmptyBlock
   }
 };
 

package/dist/index.d.ts

@@ -4,6 +4,8 @@ declare const _default: {
     rules: {
         "import-dedupe": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"importDedupe", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "generic-spacing": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"genericSpacingMismatch", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
+        "space-between-generic-and-paren": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"spaceBetweenGenericAndParenMismatch", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
+        "space-in-empty-block": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"spaceInEmptyBlockMismatch", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
     };
 };
 

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$1 = "generic-spacing";
+const RULE_NAME$3 = "generic-spacing";
 const genericSpacing = createEslintRule({
-  name: RULE_NAME$1,
+  name: RULE_NAME$3,
   meta: {
     type: "suggestion",
     docs: {
@@ -22,6 +22,32 @@ const genericSpacing = createEslintRule({
     const sourceCode = context.getSourceCode();
     return {
       TSTypeParameterDeclaration: (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 post = sourceCode.text.slice(param.range[1]);
+          const postSpace = post.match(/^(\s*)/)?.[0];
+          if (preSpace && preSpace.length) {
+            context.report({
+              node,
+              messageId: "genericSpacingMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([param.range[0] - preSpace.length, param.range[0]], "");
+              }
+            });
+          }
+          if (postSpace && postSpace.length) {
+            context.report({
+              node,
+              messageId: "genericSpacingMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([param.range[1], param.range[1] + postSpace.length], "");
+              }
+            });
+          }
+        }
         if (!["TSCallSignatureDeclaration", "ArrowFunctionExpression"].includes(node.parent.type)) {
           const pre = sourceCode.text.slice(0, node.range[0]);
           const preSpace = pre.match(/(\s+)$/)?.[0];
@@ -46,7 +72,6 @@ const genericSpacing = createEslintRule({
             });
           }
         }
-        const params = node.params;
         for (let i = 1; i < params.length; i++) {
           const prev = params[i - 1];
           const current = params[i];
@@ -93,9 +118,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME = "import-dedupe";
+const RULE_NAME$2 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$2,
   meta: {
     type: "problem",
     docs: {
@@ -143,10 +168,151 @@ const importDedupe = createEslintRule({
   }
 });
 
+const RULE_NAME$1 = "space-between-generic-and-paren";
+const spaceBetweenGenericAndParen = createEslintRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Spaces between generic type parameters and paren",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      spaceBetweenGenericAndParenMismatch: "Space between generic and paren mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      TSTypeParameter: (node) => {
+        const spaceStartRange = node.range[1] + 1;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace && postSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1
+              },
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1 + postSpace.length
+              }
+            },
+            messageId: "spaceBetweenGenericAndParenMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+            }
+          });
+        }
+        if (node.parent?.parent.type === "FunctionDeclaration") {
+          const spaceEndRange = node.range[0] - 1;
+          const pre = sourceCode.text.slice(0, spaceEndRange);
+          const preSpace = pre.match(/(\s+)$/)?.[0];
+          if (preSpace && preSpace.length) {
+            context.report({
+              loc: {
+                start: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column - preSpace.length
+                },
+                end: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column - 1
+                }
+              },
+              messageId: "spaceBetweenGenericAndParenMismatch",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+const RULE_NAME = "space-in-empty-block";
+const spaceInEmptyBlock = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Spaces in empty block",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      spaceInEmptyBlockMismatch: "Space in empty block mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    return {
+      BlockStatement: (node) => {
+        if (node.body.length) {
+          return;
+        }
+        const spaceStartRange = node.range[1] - 2;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace && postSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 2
+              },
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 2 + postSpace.length
+              }
+            },
+            messageId: "spaceInEmptyBlockMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+            }
+          });
+        }
+        const spaceEndRange = node.range[0] + 1;
+        const pre = sourceCode.text.slice(0, spaceEndRange);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (preSpace && preSpace.length) {
+          context.report({
+            loc: {
+              start: {
+                line: node.loc.start.line,
+                column: node.loc.start.column - preSpace.length
+              },
+              end: {
+                line: node.loc.start.line,
+                column: node.loc.start.column
+              }
+            },
+            messageId: "spaceInEmptyBlockMismatch",
+            *fix(fixer) {
+              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "import-dedupe": importDedupe,
-    "generic-spacing": genericSpacing
+    "generic-spacing": genericSpacing,
+    "space-between-generic-and-paren": spaceBetweenGenericAndParen,
+    "space-in-empty-block": spaceInEmptyBlock
   }
 };
 

package/package.json

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