@so1ve/eslint-plugin 0.48.0 → 0.50.1

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 const utils = require('@typescript-eslint/utils');
-const util = require('@typescript-eslint/utils/dist/ast-utils');
 const reactivity = require('@vue/reactivity');
+const util = require('@typescript-eslint/utils/dist/ast-utils');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null);
@@ -19,9 +19,81 @@ const util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$8 = "generic-spacing";
-const genericSpacing = createEslintRule({
+const RULE_NAME$8 = "array-bracket-spacing";
+const arrayBracketSpacing = createEslintRule({
   name: RULE_NAME$8,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Array bracket spacing",
+      recommended: "error"
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      arrayBracketSpacing: "Array bracket spacing mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    const text = sourceCode.getText();
+    const checkNode = (node) => {
+      const elements = node.type === utils.AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
+      const firstElement = elements[0];
+      const lastElement = elements[elements.length - 1];
+      if (!firstElement) {
+        return;
+      }
+      const leftToken = sourceCode.getTokenBefore(firstElement);
+      const rightToken = reactivity.ref(sourceCode.getTokenAfter(lastElement));
+      if (rightToken.value.value === ",") {
+        rightToken.value = sourceCode.getTokenAfter(rightToken.value);
+      }
+      const textBetweenFirstAndToken = reactivity.computed(() => text.slice(leftToken.range[1], firstElement.range[0]));
+      const isNewline = reactivity.computed(() => textBetweenFirstAndToken.value.includes("\n"));
+      const textBetweenLastAndToken = reactivity.computed(() => text.slice(lastElement.range[1], rightToken.value.range[0]));
+      const hasNewlineAfter = reactivity.computed(() => textBetweenLastAndToken.value.includes("\n"));
+      if (sourceCode.isSpaceBetween(leftToken, firstElement) && !isNewline.value) {
+        context.report({
+          node,
+          messageId: "arrayBracketSpacing",
+          *fix(fixer) {
+            yield fixer.removeRange([leftToken.range[1], firstElement.range[0]]);
+          }
+        });
+      }
+      if (sourceCode.isSpaceBetween(lastElement, rightToken.value)) {
+        if (!isNewline.value) {
+          context.report({
+            node,
+            messageId: "arrayBracketSpacing",
+            *fix(fixer) {
+              yield fixer.removeRange([lastElement.range[1], rightToken.value.range[0]]);
+            }
+          });
+        }
+      }
+      if (isNewline.value && !hasNewlineAfter.value) {
+        context.report({
+          node,
+          messageId: "arrayBracketSpacing",
+          *fix(fixer) {
+            yield fixer.replaceTextRange([lastElement.range[1], rightToken.value.range[0]], "\n");
+          }
+        });
+      }
+    };
+    return {
+      TSTupleType: checkNode,
+      ArrayExpression: checkNode
+    };
+  }
+});
+
+const RULE_NAME$7 = "generic-spacing";
+const genericSpacing = createEslintRule({
+  name: RULE_NAME$7,
   meta: {
     type: "layout",
     docs: {
@@ -159,7 +231,7 @@ const genericSpacing = createEslintRule({
         if (!node.default) {
           return;
         }
-        const endNode = node.constraint || node.name;
+        const endNode = node.constraint ?? node.name;
         const from = endNode.range[1];
         const to = node.default.range[0];
         const spaceAndEqual = sourceCode.text.slice(from, to);
@@ -289,9 +361,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$7 = "import-dedupe";
+const RULE_NAME$6 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$7,
+  name: RULE_NAME$6,
   meta: {
     type: "problem",
     docs: {
@@ -339,86 +411,61 @@ const importDedupe = createEslintRule({
   }
 });
 
-const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
-const RULE_NAME$6 = "space-between-generic-and-paren";
-const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$6,
+const RULE_NAME$5 = "no-inline-type-import";
+const noInlineTypeImport = createEslintRule({
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
-      description: "Spaces between generic type parameters and paren",
+      description: "Disallow inline type import",
       recommended: "error"
     },
-    fixable: "whitespace",
+    fixable: "code",
     schema: [],
     messages: {
-      noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
+      noInlineTypeImport: "Expected no inline type import"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    const text = sourceCode.text;
     return {
-      TSTypeParameter: (node) => {
-        const spaceStartRange = node.range[1] + 1;
-        const post = text.slice(spaceStartRange);
-        const postSpace = post.match(/^(\s*)/)?.[0];
-        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(operatorOrAnyBracketOrKeywordRE)?.[0];
-        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== utils.AST_NODE_TYPES.TSInferType) {
+      ImportDeclaration: (node) => {
+        const specifiers = node.specifiers;
+        const typeSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "type");
+        const valueSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "value");
+        if (typeSpecifiers.length && valueSpecifiers.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
-              }
-            },
-            node,
-            messageId: "noSpaceBetweenGenericAndParen",
+            loc: node.loc,
+            messageId: "noInlineTypeImport",
             *fix(fixer) {
-              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
+              const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
+              yield fixer.replaceText(
+                node,
+                `import type { ${typeSpecifiersText} } from "${node.source.value}";
+import { ${valueSpecifiersText} } from "${node.source.value}";`
+              );
+            }
+          });
+        } else if (typeSpecifiers.length) {
+          context.report({
+            loc: node.loc,
+            messageId: "noInlineTypeImport",
+            *fix(fixer) {
+              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
+              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
             }
           });
-        }
-        if (node.parent?.parent.type === utils.AST_NODE_TYPES.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
-                }
-              },
-              node,
-              messageId: "noSpaceBetweenGenericAndParen",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
-              }
-            });
-          }
         }
       }
     };
   }
 });
 
-const RULE_NAME$5 = "no-space-before-paren";
+const RULE_NAME$4 = "no-space-before-paren";
 const noSpaceBeforeParen = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$4,
   meta: {
     type: "layout",
     docs: {
@@ -460,8 +507,12 @@ const noSpaceBeforeParen = createEslintRule({
         const callerEnd = reactivity.ref(caller.range[1]);
         const textAfterCaller = reactivity.computed(() => text.slice(callerEnd.value));
         const parenStart = reactivity.ref(callerEnd.value + textAfterCaller.value.indexOf("("));
-        const textBetweenFunctionNameAndParenRange = reactivity.computed(() => [callerEnd.value, parenStart.value]);
-        const textBetweenFunctionNameAndParen = reactivity.computed(() => text.slice(...textBetweenFunctionNameAndParenRange.value));
+        const textBetweenFunctionNameAndParenRange = reactivity.computed(
+          () => [callerEnd.value, parenStart.value]
+        );
+        const textBetweenFunctionNameAndParen = reactivity.computed(
+          () => text.slice(...textBetweenFunctionNameAndParenRange.value)
+        );
         const hasGenerics = reactivity.computed(() => /^\s*</.test(textBetweenFunctionNameAndParen.value));
         const hasIndex = reactivity.computed(() => textBetweenFunctionNameAndParen.value.startsWith("]"));
         if (hasIndex.value) {
@@ -473,19 +524,25 @@ const noSpaceBeforeParen = createEslintRule({
         const spaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
         if (!hasGenerics.value) {
           if (spaces.length > 0 && textBetweenFunctionNameAndParen.value !== "?.") {
-            const textBeforeSpaces = textBetweenFunctionNameAndParen.value.slice(0, textBetweenFunctionNameAndParen.value.length - spaces.length);
+            const textBeforeSpaces = textBetweenFunctionNameAndParen.value.slice(
+              0,
+              textBetweenFunctionNameAndParen.value.length - spaces.length
+            );
             context.report({
               node,
               messageId: "noSpaceBeforeParen",
               *fix(fixer) {
-                yield fixer.replaceTextRange(textBetweenFunctionNameAndParenRange.value, textBeforeSpaces + (node.optional ? "?." : ""));
+                yield fixer.replaceTextRange(
+                  textBetweenFunctionNameAndParenRange.value,
+                  textBeforeSpaces + (node.optional ? "?." : "")
+                );
               }
             });
           }
         } else {
           const preSpaces = /^(\s*)/.exec(textBetweenFunctionNameAndParen.value)[1];
           const postSpaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
-          const spacesBeforeOptionalMark = /(\s*)\?\./.exec(textBetweenFunctionNameAndParen.value)?.[1] || "";
+          const spacesBeforeOptionalMark = /(\s*)\?\./.exec(textBetweenFunctionNameAndParen.value)?.[1] ?? "";
           if (preSpaces.length > 0) {
             context.report({
               node,
@@ -557,65 +614,48 @@ const noSpaceBeforeParen = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "space-in-empty-block";
-const spaceInEmptyBlock = createEslintRule({
-  name: RULE_NAME$4,
+const RULE_NAME$3 = "semi-spacing";
+const semiSpacing = createEslintRule({
+  name: RULE_NAME$3,
   meta: {
     type: "layout",
     docs: {
-      description: "Disallow spaces in empty block",
+      description: "Semicolon spacing in types",
       recommended: "error"
     },
     fixable: "whitespace",
     schema: [],
     messages: {
-      noSpaceInEmptyBlock: "Expected no space in empty block"
+      noSpaceBeforeSemi: "Expected no space before semicolon"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
     return {
-      BlockStatement: (node) => {
-        if (node.body.length || sourceCode.getCommentsInside(node).length) {
+      TSTypeAliasDeclaration(node) {
+        const leftToken = node.typeAnnotation;
+        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
+        if (!rightToken || rightToken.type !== utils.AST_TOKEN_TYPES.Punctuator || rightToken.value !== ";") {
           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: node.loc.start,
-              end: {
-                line: node.loc.end.line,
-                column: node.loc.end.column - 1 + postSpace.length
-              }
-            },
-            messageId: "noSpaceInEmptyBlock",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([node.range[0] + 1, 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) {
+        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
+        if (hasSpacing) {
           context.report({
             loc: {
               start: {
-                line: node.loc.start.line,
-                column: node.loc.start.column - preSpace.length
+                line: leftToken.loc.end.line,
+                column: leftToken.loc.end.column
               },
               end: {
-                line: node.loc.start.line,
-                column: node.loc.start.column
+                line: rightToken.loc.start.line,
+                column: rightToken.loc.start.column
               }
             },
-            messageId: "noSpaceInEmptyBlock",
+            node,
+            messageId: "noSpaceBeforeSemi",
             *fix(fixer) {
-              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
             }
           });
         }
@@ -624,9 +664,9 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "space-before-function-paren";
+const RULE_NAME$2 = "space-before-function-paren";
 const spaceBeforeFunctionParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$2,
   meta: {
     type: "layout",
     docs: {
@@ -731,173 +771,146 @@ const spaceBeforeFunctionParen = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "semi-spacing";
-const semiSpacing = createEslintRule({
-  name: RULE_NAME$2,
+const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
+const RULE_NAME$1 = "space-between-generic-and-paren";
+const spaceBetweenGenericAndParen = createEslintRule({
+  name: RULE_NAME$1,
   meta: {
     type: "layout",
     docs: {
-      description: "Semicolon spacing in types",
+      description: "Spaces between generic type parameters and paren",
       recommended: "error"
     },
     fixable: "whitespace",
     schema: [],
     messages: {
-      noSpaceBeforeSemi: "Expected no space before semicolon"
+      noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
+    const text = sourceCode.text;
     return {
-      TSTypeAliasDeclaration(node) {
-        const leftToken = node.typeAnnotation;
-        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
-        if (!rightToken || rightToken.type !== utils.AST_TOKEN_TYPES.Punctuator || rightToken.value !== ";") {
-          return;
-        }
-        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
-        if (hasSpacing) {
+      TSTypeParameter: (node) => {
+        const spaceStartRange = node.range[1] + 1;
+        const post = text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        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(operatorOrAnyBracketOrKeywordRE)?.[0];
+        if (postSpace?.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== utils.AST_NODE_TYPES.TSInferType) {
           context.report({
             loc: {
               start: {
-                line: leftToken.loc.end.line,
-                column: leftToken.loc.end.column
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1
               },
               end: {
-                line: rightToken.loc.start.line,
-                column: rightToken.loc.start.column
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1 + postSpace.length
               }
             },
             node,
-            messageId: "noSpaceBeforeSemi",
+            messageId: "noSpaceBetweenGenericAndParen",
             *fix(fixer) {
-              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
             }
           });
         }
+        if (node.parent?.parent.type === utils.AST_NODE_TYPES.FunctionDeclaration) {
+          const spaceEndRange = node.range[0] - 1;
+          const pre = sourceCode.text.slice(0, spaceEndRange);
+          const preSpace = pre.match(/(\s+)$/)?.[0];
+          if (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
+                }
+              },
+              node,
+              messageId: "noSpaceBetweenGenericAndParen",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              }
+            });
+          }
+        }
       }
     };
   }
 });
 
-const RULE_NAME$1 = "no-inline-type-import";
-const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$1,
+const RULE_NAME = "space-in-empty-block";
+const spaceInEmptyBlock = createEslintRule({
+  name: RULE_NAME,
   meta: {
     type: "layout",
     docs: {
-      description: "Disallow inline type import",
+      description: "Disallow spaces in empty block",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
-      noInlineTypeImport: "Expected no inline type import"
+      noSpaceInEmptyBlock: "Expected no space in empty block"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
     return {
-      ImportDeclaration: (node) => {
-        const specifiers = node.specifiers;
-        const typeSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "type");
-        const valueSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "value");
-        if (typeSpecifiers.length && valueSpecifiers.length) {
-          context.report({
-            loc: node.loc,
-            messageId: "noInlineTypeImport",
-            *fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
-              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";
-import { ${valueSpecifiersText} } from "${node.source.value}";`);
-            }
-          });
-        } else if (typeSpecifiers.length) {
+      BlockStatement: (node) => {
+        if (node.body.length || sourceCode.getCommentsInside(node).length) {
+          return;
+        }
+        const spaceStartRange = node.range[1] - 2;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace?.length) {
           context.report({
-            loc: node.loc,
-            messageId: "noInlineTypeImport",
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 1 + postSpace.length
+              }
+            },
+            messageId: "noSpaceInEmptyBlock",
             *fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
+              yield fixer.replaceTextRange([node.range[0] + 1, spaceStartRange + postSpace.length], "");
             }
           });
         }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "array-bracket-spacing";
-const arrayBracketSpacing = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Array bracket spacing",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      arrayBracketSpacing: "Array bracket spacing mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.getText();
-    const checkNode = (node) => {
-      const elements = node.type === utils.AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
-      const firstElement = elements[0];
-      const lastElement = elements[elements.length - 1];
-      if (!firstElement) {
-        return;
-      }
-      const leftToken = sourceCode.getTokenBefore(firstElement);
-      const rightToken = reactivity.ref(sourceCode.getTokenAfter(lastElement));
-      if (rightToken.value.value === ",") {
-        rightToken.value = sourceCode.getTokenAfter(rightToken.value);
-      }
-      const textBetweenFirstAndToken = reactivity.computed(() => text.slice(leftToken.range[1], firstElement.range[0]));
-      const isNewline = reactivity.computed(() => textBetweenFirstAndToken.value.includes("\n"));
-      const textBetweenLastAndToken = reactivity.computed(() => text.slice(lastElement.range[1], rightToken.value.range[0]));
-      const hasNewlineAfter = reactivity.computed(() => textBetweenLastAndToken.value.includes("\n"));
-      if (sourceCode.isSpaceBetween(leftToken, firstElement) && !isNewline.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.removeRange([leftToken.range[1], firstElement.range[0]]);
-          }
-        });
-      }
-      if (sourceCode.isSpaceBetween(lastElement, rightToken.value)) {
-        if (!isNewline.value) {
+        const spaceEndRange = node.range[0] + 1;
+        const pre = sourceCode.text.slice(0, spaceEndRange);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (preSpace?.length) {
           context.report({
-            node,
-            messageId: "arrayBracketSpacing",
+            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: "noSpaceInEmptyBlock",
             *fix(fixer) {
-              yield fixer.removeRange([lastElement.range[1], rightToken.value.range[0]]);
+              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
             }
           });
         }
       }
-      if (isNewline.value && !hasNewlineAfter.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.replaceTextRange([lastElement.range[1], rightToken.value.range[0]], "\n");
-          }
-        });
-      }
-    };
-    return {
-      TSTupleType: checkNode,
-      ArrayExpression: checkNode
     };
   }
 });

package/dist/index.mjs

@@ -1,12 +1,84 @@
 import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
-import * as util from '@typescript-eslint/utils/dist/ast-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$8 = "generic-spacing";
-const genericSpacing = createEslintRule({
+const RULE_NAME$8 = "array-bracket-spacing";
+const arrayBracketSpacing = createEslintRule({
   name: RULE_NAME$8,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Array bracket spacing",
+      recommended: "error"
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      arrayBracketSpacing: "Array bracket spacing mismatch"
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    const text = sourceCode.getText();
+    const checkNode = (node) => {
+      const elements = node.type === AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
+      const firstElement = elements[0];
+      const lastElement = elements[elements.length - 1];
+      if (!firstElement) {
+        return;
+      }
+      const leftToken = sourceCode.getTokenBefore(firstElement);
+      const rightToken = ref(sourceCode.getTokenAfter(lastElement));
+      if (rightToken.value.value === ",") {
+        rightToken.value = sourceCode.getTokenAfter(rightToken.value);
+      }
+      const textBetweenFirstAndToken = computed(() => text.slice(leftToken.range[1], firstElement.range[0]));
+      const isNewline = computed(() => textBetweenFirstAndToken.value.includes("\n"));
+      const textBetweenLastAndToken = computed(() => text.slice(lastElement.range[1], rightToken.value.range[0]));
+      const hasNewlineAfter = computed(() => textBetweenLastAndToken.value.includes("\n"));
+      if (sourceCode.isSpaceBetween(leftToken, firstElement) && !isNewline.value) {
+        context.report({
+          node,
+          messageId: "arrayBracketSpacing",
+          *fix(fixer) {
+            yield fixer.removeRange([leftToken.range[1], firstElement.range[0]]);
+          }
+        });
+      }
+      if (sourceCode.isSpaceBetween(lastElement, rightToken.value)) {
+        if (!isNewline.value) {
+          context.report({
+            node,
+            messageId: "arrayBracketSpacing",
+            *fix(fixer) {
+              yield fixer.removeRange([lastElement.range[1], rightToken.value.range[0]]);
+            }
+          });
+        }
+      }
+      if (isNewline.value && !hasNewlineAfter.value) {
+        context.report({
+          node,
+          messageId: "arrayBracketSpacing",
+          *fix(fixer) {
+            yield fixer.replaceTextRange([lastElement.range[1], rightToken.value.range[0]], "\n");
+          }
+        });
+      }
+    };
+    return {
+      TSTupleType: checkNode,
+      ArrayExpression: checkNode
+    };
+  }
+});
+
+const RULE_NAME$7 = "generic-spacing";
+const genericSpacing = createEslintRule({
+  name: RULE_NAME$7,
   meta: {
     type: "layout",
     docs: {
@@ -144,7 +216,7 @@ const genericSpacing = createEslintRule({
         if (!node.default) {
           return;
         }
-        const endNode = node.constraint || node.name;
+        const endNode = node.constraint ?? node.name;
         const from = endNode.range[1];
         const to = node.default.range[0];
         const spaceAndEqual = sourceCode.text.slice(from, to);
@@ -274,9 +346,9 @@ const genericSpacing = createEslintRule({
   }
 });
 
-const RULE_NAME$7 = "import-dedupe";
+const RULE_NAME$6 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$7,
+  name: RULE_NAME$6,
   meta: {
     type: "problem",
     docs: {
@@ -324,86 +396,61 @@ const importDedupe = createEslintRule({
   }
 });
 
-const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
-const RULE_NAME$6 = "space-between-generic-and-paren";
-const spaceBetweenGenericAndParen = createEslintRule({
-  name: RULE_NAME$6,
+const RULE_NAME$5 = "no-inline-type-import";
+const noInlineTypeImport = createEslintRule({
+  name: RULE_NAME$5,
   meta: {
     type: "layout",
     docs: {
-      description: "Spaces between generic type parameters and paren",
+      description: "Disallow inline type import",
       recommended: "error"
     },
-    fixable: "whitespace",
+    fixable: "code",
     schema: [],
     messages: {
-      noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
+      noInlineTypeImport: "Expected no inline type import"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    const text = sourceCode.text;
     return {
-      TSTypeParameter: (node) => {
-        const spaceStartRange = node.range[1] + 1;
-        const post = text.slice(spaceStartRange);
-        const postSpace = post.match(/^(\s*)/)?.[0];
-        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(operatorOrAnyBracketOrKeywordRE)?.[0];
-        if (postSpace && postSpace.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== AST_NODE_TYPES.TSInferType) {
+      ImportDeclaration: (node) => {
+        const specifiers = node.specifiers;
+        const typeSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "type");
+        const valueSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "value");
+        if (typeSpecifiers.length && valueSpecifiers.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
-              }
-            },
-            node,
-            messageId: "noSpaceBetweenGenericAndParen",
+            loc: node.loc,
+            messageId: "noInlineTypeImport",
             *fix(fixer) {
-              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
+              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
+              const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
+              yield fixer.replaceText(
+                node,
+                `import type { ${typeSpecifiersText} } from "${node.source.value}";
+import { ${valueSpecifiersText} } from "${node.source.value}";`
+              );
+            }
+          });
+        } else if (typeSpecifiers.length) {
+          context.report({
+            loc: node.loc,
+            messageId: "noInlineTypeImport",
+            *fix(fixer) {
+              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
+              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
             }
           });
-        }
-        if (node.parent?.parent.type === AST_NODE_TYPES.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
-                }
-              },
-              node,
-              messageId: "noSpaceBetweenGenericAndParen",
-              *fix(fixer) {
-                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
-              }
-            });
-          }
         }
       }
     };
   }
 });
 
-const RULE_NAME$5 = "no-space-before-paren";
+const RULE_NAME$4 = "no-space-before-paren";
 const noSpaceBeforeParen = createEslintRule({
-  name: RULE_NAME$5,
+  name: RULE_NAME$4,
   meta: {
     type: "layout",
     docs: {
@@ -445,8 +492,12 @@ const noSpaceBeforeParen = createEslintRule({
         const callerEnd = ref(caller.range[1]);
         const textAfterCaller = computed(() => text.slice(callerEnd.value));
         const parenStart = ref(callerEnd.value + textAfterCaller.value.indexOf("("));
-        const textBetweenFunctionNameAndParenRange = computed(() => [callerEnd.value, parenStart.value]);
-        const textBetweenFunctionNameAndParen = computed(() => text.slice(...textBetweenFunctionNameAndParenRange.value));
+        const textBetweenFunctionNameAndParenRange = computed(
+          () => [callerEnd.value, parenStart.value]
+        );
+        const textBetweenFunctionNameAndParen = computed(
+          () => text.slice(...textBetweenFunctionNameAndParenRange.value)
+        );
         const hasGenerics = computed(() => /^\s*</.test(textBetweenFunctionNameAndParen.value));
         const hasIndex = computed(() => textBetweenFunctionNameAndParen.value.startsWith("]"));
         if (hasIndex.value) {
@@ -458,19 +509,25 @@ const noSpaceBeforeParen = createEslintRule({
         const spaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
         if (!hasGenerics.value) {
           if (spaces.length > 0 && textBetweenFunctionNameAndParen.value !== "?.") {
-            const textBeforeSpaces = textBetweenFunctionNameAndParen.value.slice(0, textBetweenFunctionNameAndParen.value.length - spaces.length);
+            const textBeforeSpaces = textBetweenFunctionNameAndParen.value.slice(
+              0,
+              textBetweenFunctionNameAndParen.value.length - spaces.length
+            );
             context.report({
               node,
               messageId: "noSpaceBeforeParen",
               *fix(fixer) {
-                yield fixer.replaceTextRange(textBetweenFunctionNameAndParenRange.value, textBeforeSpaces + (node.optional ? "?." : ""));
+                yield fixer.replaceTextRange(
+                  textBetweenFunctionNameAndParenRange.value,
+                  textBeforeSpaces + (node.optional ? "?." : "")
+                );
               }
             });
           }
         } else {
           const preSpaces = /^(\s*)/.exec(textBetweenFunctionNameAndParen.value)[1];
           const postSpaces = /(\s*)$/.exec(textBetweenFunctionNameAndParen.value)[1];
-          const spacesBeforeOptionalMark = /(\s*)\?\./.exec(textBetweenFunctionNameAndParen.value)?.[1] || "";
+          const spacesBeforeOptionalMark = /(\s*)\?\./.exec(textBetweenFunctionNameAndParen.value)?.[1] ?? "";
           if (preSpaces.length > 0) {
             context.report({
               node,
@@ -542,65 +599,48 @@ const noSpaceBeforeParen = createEslintRule({
   }
 });
 
-const RULE_NAME$4 = "space-in-empty-block";
-const spaceInEmptyBlock = createEslintRule({
-  name: RULE_NAME$4,
+const RULE_NAME$3 = "semi-spacing";
+const semiSpacing = createEslintRule({
+  name: RULE_NAME$3,
   meta: {
     type: "layout",
     docs: {
-      description: "Disallow spaces in empty block",
+      description: "Semicolon spacing in types",
       recommended: "error"
     },
     fixable: "whitespace",
     schema: [],
     messages: {
-      noSpaceInEmptyBlock: "Expected no space in empty block"
+      noSpaceBeforeSemi: "Expected no space before semicolon"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
     return {
-      BlockStatement: (node) => {
-        if (node.body.length || sourceCode.getCommentsInside(node).length) {
+      TSTypeAliasDeclaration(node) {
+        const leftToken = node.typeAnnotation;
+        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
+        if (!rightToken || rightToken.type !== AST_TOKEN_TYPES.Punctuator || rightToken.value !== ";") {
           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: node.loc.start,
-              end: {
-                line: node.loc.end.line,
-                column: node.loc.end.column - 1 + postSpace.length
-              }
-            },
-            messageId: "noSpaceInEmptyBlock",
-            *fix(fixer) {
-              yield fixer.replaceTextRange([node.range[0] + 1, 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) {
+        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
+        if (hasSpacing) {
           context.report({
             loc: {
               start: {
-                line: node.loc.start.line,
-                column: node.loc.start.column - preSpace.length
+                line: leftToken.loc.end.line,
+                column: leftToken.loc.end.column
               },
               end: {
-                line: node.loc.start.line,
-                column: node.loc.start.column
+                line: rightToken.loc.start.line,
+                column: rightToken.loc.start.column
               }
             },
-            messageId: "noSpaceInEmptyBlock",
+            node,
+            messageId: "noSpaceBeforeSemi",
             *fix(fixer) {
-              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
             }
           });
         }
@@ -609,9 +649,9 @@ const spaceInEmptyBlock = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "space-before-function-paren";
+const RULE_NAME$2 = "space-before-function-paren";
 const spaceBeforeFunctionParen = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$2,
   meta: {
     type: "layout",
     docs: {
@@ -716,173 +756,146 @@ const spaceBeforeFunctionParen = createEslintRule({
   }
 });
 
-const RULE_NAME$2 = "semi-spacing";
-const semiSpacing = createEslintRule({
-  name: RULE_NAME$2,
+const operatorOrAnyBracketOrKeywordRE = /^(\||&|\*|\+|\-|\/|%|<|>|<=|>=|==|!=|===|!==|\[|\(|\{|as|extends|implements|keyof|new|readonly|typeof|unique|unknown)/;
+const RULE_NAME$1 = "space-between-generic-and-paren";
+const spaceBetweenGenericAndParen = createEslintRule({
+  name: RULE_NAME$1,
   meta: {
     type: "layout",
     docs: {
-      description: "Semicolon spacing in types",
+      description: "Spaces between generic type parameters and paren",
       recommended: "error"
     },
     fixable: "whitespace",
     schema: [],
     messages: {
-      noSpaceBeforeSemi: "Expected no space before semicolon"
+      noSpaceBetweenGenericAndParen: "Expected no space between generic type parameters and paren"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
+    const text = sourceCode.text;
     return {
-      TSTypeAliasDeclaration(node) {
-        const leftToken = node.typeAnnotation;
-        const rightToken = sourceCode.getTokenAfter(node.typeAnnotation);
-        if (!rightToken || rightToken.type !== AST_TOKEN_TYPES.Punctuator || rightToken.value !== ";") {
-          return;
-        }
-        const hasSpacing = sourceCode.isSpaceBetween(leftToken, rightToken);
-        if (hasSpacing) {
+      TSTypeParameter: (node) => {
+        const spaceStartRange = node.range[1] + 1;
+        const post = text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        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(operatorOrAnyBracketOrKeywordRE)?.[0];
+        if (postSpace?.length && !postEqual && !postComma && !postQuestionMark && !postOperatorOrAnyBracketOrKeyword && node.parent.type !== AST_NODE_TYPES.TSInferType) {
           context.report({
             loc: {
               start: {
-                line: leftToken.loc.end.line,
-                column: leftToken.loc.end.column
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1
               },
               end: {
-                line: rightToken.loc.start.line,
-                column: rightToken.loc.start.column
+                line: node.loc.end.line,
+                column: node.loc.end.column + 1 + postSpace.length
               }
             },
             node,
-            messageId: "noSpaceBeforeSemi",
+            messageId: "noSpaceBetweenGenericAndParen",
             *fix(fixer) {
-              yield fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+              yield fixer.replaceTextRange([spaceStartRange, spaceStartRange + postSpace.length], "");
             }
           });
         }
+        if (node.parent?.parent.type === AST_NODE_TYPES.FunctionDeclaration) {
+          const spaceEndRange = node.range[0] - 1;
+          const pre = sourceCode.text.slice(0, spaceEndRange);
+          const preSpace = pre.match(/(\s+)$/)?.[0];
+          if (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
+                }
+              },
+              node,
+              messageId: "noSpaceBetweenGenericAndParen",
+              *fix(fixer) {
+                yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
+              }
+            });
+          }
+        }
       }
     };
   }
 });
 
-const RULE_NAME$1 = "no-inline-type-import";
-const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$1,
+const RULE_NAME = "space-in-empty-block";
+const spaceInEmptyBlock = createEslintRule({
+  name: RULE_NAME,
   meta: {
     type: "layout",
     docs: {
-      description: "Disallow inline type import",
+      description: "Disallow spaces in empty block",
       recommended: "error"
     },
-    fixable: "code",
+    fixable: "whitespace",
     schema: [],
     messages: {
-      noInlineTypeImport: "Expected no inline type import"
+      noSpaceInEmptyBlock: "Expected no space in empty block"
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
     return {
-      ImportDeclaration: (node) => {
-        const specifiers = node.specifiers;
-        const typeSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "type");
-        const valueSpecifiers = specifiers.filter((s) => s.type === "ImportSpecifier" && s.importKind === "value");
-        if (typeSpecifiers.length && valueSpecifiers.length) {
-          context.report({
-            loc: node.loc,
-            messageId: "noInlineTypeImport",
-            *fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
-              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";
-import { ${valueSpecifiersText} } from "${node.source.value}";`);
-            }
-          });
-        } else if (typeSpecifiers.length) {
+      BlockStatement: (node) => {
+        if (node.body.length || sourceCode.getCommentsInside(node).length) {
+          return;
+        }
+        const spaceStartRange = node.range[1] - 2;
+        const post = sourceCode.text.slice(spaceStartRange);
+        const postSpace = post.match(/^(\s*)/)?.[0];
+        if (postSpace?.length) {
           context.report({
-            loc: node.loc,
-            messageId: "noInlineTypeImport",
+            loc: {
+              start: node.loc.start,
+              end: {
+                line: node.loc.end.line,
+                column: node.loc.end.column - 1 + postSpace.length
+              }
+            },
+            messageId: "noSpaceInEmptyBlock",
             *fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              yield fixer.replaceText(node, `import type { ${typeSpecifiersText} } from "${node.source.value}";`);
+              yield fixer.replaceTextRange([node.range[0] + 1, spaceStartRange + postSpace.length], "");
             }
           });
         }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "array-bracket-spacing";
-const arrayBracketSpacing = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Array bracket spacing",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      arrayBracketSpacing: "Array bracket spacing mismatch"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    const text = sourceCode.getText();
-    const checkNode = (node) => {
-      const elements = node.type === AST_NODE_TYPES.TSTupleType ? node.elementTypes : node.elements;
-      const firstElement = elements[0];
-      const lastElement = elements[elements.length - 1];
-      if (!firstElement) {
-        return;
-      }
-      const leftToken = sourceCode.getTokenBefore(firstElement);
-      const rightToken = ref(sourceCode.getTokenAfter(lastElement));
-      if (rightToken.value.value === ",") {
-        rightToken.value = sourceCode.getTokenAfter(rightToken.value);
-      }
-      const textBetweenFirstAndToken = computed(() => text.slice(leftToken.range[1], firstElement.range[0]));
-      const isNewline = computed(() => textBetweenFirstAndToken.value.includes("\n"));
-      const textBetweenLastAndToken = computed(() => text.slice(lastElement.range[1], rightToken.value.range[0]));
-      const hasNewlineAfter = computed(() => textBetweenLastAndToken.value.includes("\n"));
-      if (sourceCode.isSpaceBetween(leftToken, firstElement) && !isNewline.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.removeRange([leftToken.range[1], firstElement.range[0]]);
-          }
-        });
-      }
-      if (sourceCode.isSpaceBetween(lastElement, rightToken.value)) {
-        if (!isNewline.value) {
+        const spaceEndRange = node.range[0] + 1;
+        const pre = sourceCode.text.slice(0, spaceEndRange);
+        const preSpace = pre.match(/(\s+)$/)?.[0];
+        if (preSpace?.length) {
           context.report({
-            node,
-            messageId: "arrayBracketSpacing",
+            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: "noSpaceInEmptyBlock",
             *fix(fixer) {
-              yield fixer.removeRange([lastElement.range[1], rightToken.value.range[0]]);
+              yield fixer.replaceTextRange([spaceEndRange - preSpace.length, spaceEndRange], "");
             }
           });
         }
       }
-      if (isNewline.value && !hasNewlineAfter.value) {
-        context.report({
-          node,
-          messageId: "arrayBracketSpacing",
-          *fix(fixer) {
-            yield fixer.replaceTextRange([lastElement.range[1], rightToken.value.range[0]], "\n");
-          }
-        });
-      }
-    };
-    return {
-      TSTupleType: checkNode,
-      ArrayExpression: checkNode
     };
   }
 });

package/package.json

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