@so1ve/eslint-plugin 0.75.0 → 0.77.0

package/dist/index.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
 const utils = require('@typescript-eslint/utils');
+const types = require('@typescript-eslint/types');
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$4 = "import-dedupe";
+const RULE_NAME$3 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$3,
   meta: {
     type: "problem",
     docs: {
@@ -20,43 +21,41 @@ const importDedupe = createEslintRule({
     }
   },
   defaultOptions: [],
-  create: (context) => {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1) {
-          return;
-        }
-        const names = /* @__PURE__ */ new Set();
-        for (const n of node.specifiers) {
-          const id = n.local.name;
-          if (names.has(id)) {
-            context.report({
-              node,
-              loc: {
-                start: n.loc.end,
-                end: n.loc.start
-              },
-              messageId: "importDedupe",
-              fix(fixer) {
-                const s = n.range[0];
-                let e = n.range[1];
-                if (context.getSourceCode().text[e] === ",") {
-                  e += 1;
-                }
-                return fixer.removeRange([s, e]);
+  create: (context) => ({
+    ImportDeclaration(node) {
+      if (node.specifiers.length <= 1) {
+        return;
+      }
+      const names = /* @__PURE__ */ new Set();
+      for (const n of node.specifiers) {
+        const id = n.local.name;
+        if (names.has(id)) {
+          context.report({
+            node,
+            loc: {
+              start: n.loc.end,
+              end: n.loc.start
+            },
+            messageId: "importDedupe",
+            fix(fixer) {
+              const s = n.range[0];
+              let e = n.range[1];
+              if (context.getSourceCode().text[e] === ",") {
+                e += 1;
               }
-            });
-          }
-          names.add(id);
+              return fixer.removeRange([s, e]);
+            }
+          });
         }
+        names.add(id);
       }
-    };
-  }
+    }
+  })
 });
 
-const RULE_NAME$3 = "no-inline-type-import";
+const RULE_NAME$2 = "no-inline-type-import";
 const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$2,
   meta: {
     type: "layout",
     docs: {
@@ -76,10 +75,13 @@ const noInlineTypeImport = createEslintRule({
       ImportDeclaration: (node) => {
         const specifiers = node.specifiers;
         const typeSpecifiers = specifiers.filter(
-          (s) => s.type === "ImportSpecifier" && s.importKind === "type"
+          (s) => s.type === types.AST_NODE_TYPES.ImportSpecifier && s.importKind === "type"
         );
         const valueSpecifiers = specifiers.filter(
-          (s) => s.type === "ImportSpecifier" && s.importKind === "value"
+          (s) => s.type === types.AST_NODE_TYPES.ImportSpecifier && s.importKind === "value"
+        );
+        const defaultImportSpecifier = specifiers.find(
+          (s) => s.type === types.AST_NODE_TYPES.ImportDefaultSpecifier
         );
         if (typeSpecifiers.length > 0 && valueSpecifiers.length > 0) {
           context.report({
@@ -88,11 +90,15 @@ const noInlineTypeImport = createEslintRule({
             *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}";`
+              const defaultImportSpecifierText = sourceCode.getText(
+                defaultImportSpecifier
               );
+              const valueSpecifiersTextWithDefaultImport = defaultImportSpecifier ? `import ${defaultImportSpecifierText}, { ${valueSpecifiersText} } from "${node.source.value}";` : `import { ${valueSpecifiersText} } from "${node.source.value}";`;
+              const texts = [
+                `import type { ${typeSpecifiersText} } from "${node.source.value}";`,
+                valueSpecifiersTextWithDefaultImport
+              ];
+              yield fixer.replaceText(node, texts.join("\n"));
             }
           });
         } else if (typeSpecifiers.length > 0) {
@@ -113,9 +119,9 @@ import { ${valueSpecifiersText} } from "${node.source.value}";`
   }
 });
 
-const RULE_NAME$2 = "no-useless-template-string";
+const RULE_NAME$1 = "no-useless-template-string";
 const noUselessTemplateString = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$1,
   meta: {
     type: "problem",
     docs: {
@@ -129,32 +135,44 @@ const noUselessTemplateString = createEslintRule({
     }
   },
   defaultOptions: [],
-  create: (context) => {
-    return {
-      TemplateLiteral(node) {
-        const hasNewline = node.quasis.some((n) => n.value.raw.includes("\n"));
-        if (node.expressions.length === 0 && !hasNewline) {
-          context.report({
-            node,
-            messageId: "noUselessTemplateString",
-            fix(fixer) {
-              const s = node.range[0];
-              const e = node.range[1];
-              return fixer.replaceTextRange(
-                [s, e],
-                `"${node.quasis[0].value.raw}"`
-              );
-            }
-          });
-        }
+  create: (context) => ({
+    TemplateLiteral(node) {
+      const hasNewline = node.quasis.some((n) => n.value.raw.includes("\n"));
+      if (node.expressions.length === 0 && !hasNewline) {
+        context.report({
+          node,
+          messageId: "noUselessTemplateString",
+          fix(fixer) {
+            const s = node.range[0];
+            const e = node.range[1];
+            return fixer.replaceTextRange(
+              [s, e],
+              `"${node.quasis[0].value.raw}"`
+            );
+          }
+        });
       }
-    };
-  }
+    }
+  })
 });
 
-const RULE_NAME$1 = "pad-after-last-import";
-const padAfterLastImport = createEslintRule({
-  name: RULE_NAME$1,
+const RULE_NAME = "function-style";
+const START_RETURN = /^return /;
+const END_SEMICOLON = /;$/;
+function getBeforeNode(node) {
+  const { parent } = node;
+  if (!parent)
+    return;
+  const { body } = parent;
+  if (!body)
+    return;
+  const index = body.indexOf(node);
+  if (index === 0)
+    return;
+  return body[index - 1];
+}
+const functionStyle = createEslintRule({
+  name: RULE_NAME,
   meta: {
     type: "problem",
     docs: {
@@ -164,71 +182,88 @@ const padAfterLastImport = createEslintRule({
     fixable: "code",
     schema: [],
     messages: {
-      padAfterLastImport: "Expected a blank line after the last import."
+      arrow: "Expected an arrow function.",
+      arrowShorthand: "Expected an arrow function shorthand.",
+      declaration: "Expected a function declaration."
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    let lastImportNode = null;
+    const text = sourceCode.getText();
+    const getStatementRaw = (statement) => `(${text.slice(statement.range[0], statement.range[1]).replace(START_RETURN, "").replace(END_SEMICOLON, "")})`;
+    function getLonelyReturnStatement(node) {
+      const { body } = node;
+      if (body.type === types.AST_NODE_TYPES.BlockStatement) {
+        const { body: blockBody } = body;
+        if (blockBody.length === 1) {
+          const [statement] = blockBody;
+          if (statement?.type === types.AST_NODE_TYPES.ReturnStatement) {
+            return statement;
+          }
+        }
+      }
+    }
+    function generateFunction(node, type) {
+      const async = node.async ? "async " : "";
+      const params = node.params.map((param) => sourceCode.getText(param)).join(", ");
+      const generics = node.typeParameters ? sourceCode.getText(node.typeParameters) : "";
+      const body = sourceCode.getText(node.body);
+      return type === "arrow" ? `const ${node.id.name} = ${async}${generics}(${params}) => ${body};` : `${async}function ${node.parent.id.name}${generics}(${params}) ${body}`;
+    }
     return {
-      ImportDeclaration(node) {
-        lastImportNode = node;
+      FunctionDeclaration(node) {
+        if (!node.id?.name)
+          return;
+        const statement = getLonelyReturnStatement(node);
+        if (!statement || node.generator || getBeforeNode(node)?.type === types.AST_NODE_TYPES.TSDeclareFunction)
+          return;
+        context.report({
+          node,
+          messageId: "arrow",
+          fix: (fixer) => {
+            const [start, end] = node.range;
+            return fixer.replaceTextRange(
+              [start, end],
+              generateFunction(node, "arrow")
+            );
+          }
+        });
       },
-      "Program:exit"() {
-        if (lastImportNode) {
-          const nextToken = sourceCode.getTokenAfter(lastImportNode);
-          if (nextToken && // Workaround: Vue
-          nextToken.value !== "<\/script>" && lastImportNode.loc.end.line + 1 === nextToken.loc.start.line) {
+      ArrowFunctionExpression(node) {
+        const { body, parent } = node;
+        if (parent?.id?.typeAnnotation)
+          return;
+        if (body.type === types.AST_NODE_TYPES.BlockStatement) {
+          const { body: blockBody } = body;
+          if (blockBody.length > 1 && node.parent?.parent?.type === types.AST_NODE_TYPES.VariableDeclaration) {
+            const parent2 = node.parent.parent;
             context.report({
-              node: lastImportNode,
-              messageId: "padAfterLastImport",
-              fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
+              node: parent2,
+              messageId: "declaration",
+              fix: (fixer) => {
+                const [start, end] = parent2.range;
+                return fixer.replaceTextRange(
+                  [start, end],
+                  generateFunction(node, "declaration")
+                );
+              }
             });
           }
         }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "no-beginning-newline";
-const noBeginningNewline = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "No beginning newline",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noBeginningNewline: "No beginning newline"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const text = context.getSourceCode().text;
-    return {
-      Program: (node) => {
-        const newlines = text.match(/([\n]*)/)[1];
-        if (newlines.length > 0) {
+        const statement = getLonelyReturnStatement(node);
+        if (statement)
           context.report({
             node,
-            loc: {
-              start: {
-                line: 0,
-                column: 0
-              },
-              end: node.loc.start
-            },
-            messageId: "noBeginningNewline",
-            *fix(fixer) {
-              yield fixer.removeRange([0, node.range[0]]);
+            messageId: "arrowShorthand",
+            fix: (fixer) => {
+              const [start, end] = node.body.range;
+              return fixer.replaceTextRange(
+                [start, end],
+                getStatementRaw(statement)
+              );
             }
           });
-        }
       }
     };
   }
@@ -239,8 +274,7 @@ const index = {
     "import-dedupe": importDedupe,
     "no-inline-type-import": noInlineTypeImport,
     "no-useless-template-string": noUselessTemplateString,
-    "no-beginning-newline": noBeginningNewline,
-    "pad-after-last-import": padAfterLastImport
+    "function-style": functionStyle
   }
 };
 

package/dist/index.d.ts

@@ -1,12 +1,13 @@
 import * as _typescript_eslint_utils_dist_ts_eslint_Rule from '@typescript-eslint/utils/dist/ts-eslint/Rule';
 
+type MessageIds = "arrow" | "arrowShorthand" | "declaration";
+
 declare const _default: {
     rules: {
         "import-dedupe": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"importDedupe", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "no-inline-type-import": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noInlineTypeImport", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
         "no-useless-template-string": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noUselessTemplateString", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
-        "no-beginning-newline": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"noBeginningNewline", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
-        "pad-after-last-import": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<"padAfterLastImport", [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
+        "function-style": _typescript_eslint_utils_dist_ts_eslint_Rule.RuleModule<MessageIds, [], _typescript_eslint_utils_dist_ts_eslint_Rule.RuleListener>;
     };
 };
 

package/dist/index.mjs

@@ -1,10 +1,11 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
 
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
-const RULE_NAME$4 = "import-dedupe";
+const RULE_NAME$3 = "import-dedupe";
 const importDedupe = createEslintRule({
-  name: RULE_NAME$4,
+  name: RULE_NAME$3,
   meta: {
     type: "problem",
     docs: {
@@ -18,43 +19,41 @@ const importDedupe = createEslintRule({
     }
   },
   defaultOptions: [],
-  create: (context) => {
-    return {
-      ImportDeclaration(node) {
-        if (node.specifiers.length <= 1) {
-          return;
-        }
-        const names = /* @__PURE__ */ new Set();
-        for (const n of node.specifiers) {
-          const id = n.local.name;
-          if (names.has(id)) {
-            context.report({
-              node,
-              loc: {
-                start: n.loc.end,
-                end: n.loc.start
-              },
-              messageId: "importDedupe",
-              fix(fixer) {
-                const s = n.range[0];
-                let e = n.range[1];
-                if (context.getSourceCode().text[e] === ",") {
-                  e += 1;
-                }
-                return fixer.removeRange([s, e]);
+  create: (context) => ({
+    ImportDeclaration(node) {
+      if (node.specifiers.length <= 1) {
+        return;
+      }
+      const names = /* @__PURE__ */ new Set();
+      for (const n of node.specifiers) {
+        const id = n.local.name;
+        if (names.has(id)) {
+          context.report({
+            node,
+            loc: {
+              start: n.loc.end,
+              end: n.loc.start
+            },
+            messageId: "importDedupe",
+            fix(fixer) {
+              const s = n.range[0];
+              let e = n.range[1];
+              if (context.getSourceCode().text[e] === ",") {
+                e += 1;
               }
-            });
-          }
-          names.add(id);
+              return fixer.removeRange([s, e]);
+            }
+          });
         }
+        names.add(id);
       }
-    };
-  }
+    }
+  })
 });
 
-const RULE_NAME$3 = "no-inline-type-import";
+const RULE_NAME$2 = "no-inline-type-import";
 const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$3,
+  name: RULE_NAME$2,
   meta: {
     type: "layout",
     docs: {
@@ -74,10 +73,13 @@ const noInlineTypeImport = createEslintRule({
       ImportDeclaration: (node) => {
         const specifiers = node.specifiers;
         const typeSpecifiers = specifiers.filter(
-          (s) => s.type === "ImportSpecifier" && s.importKind === "type"
+          (s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "type"
         );
         const valueSpecifiers = specifiers.filter(
-          (s) => s.type === "ImportSpecifier" && s.importKind === "value"
+          (s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "value"
+        );
+        const defaultImportSpecifier = specifiers.find(
+          (s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier
         );
         if (typeSpecifiers.length > 0 && valueSpecifiers.length > 0) {
           context.report({
@@ -86,11 +88,15 @@ const noInlineTypeImport = createEslintRule({
             *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}";`
+              const defaultImportSpecifierText = sourceCode.getText(
+                defaultImportSpecifier
               );
+              const valueSpecifiersTextWithDefaultImport = defaultImportSpecifier ? `import ${defaultImportSpecifierText}, { ${valueSpecifiersText} } from "${node.source.value}";` : `import { ${valueSpecifiersText} } from "${node.source.value}";`;
+              const texts = [
+                `import type { ${typeSpecifiersText} } from "${node.source.value}";`,
+                valueSpecifiersTextWithDefaultImport
+              ];
+              yield fixer.replaceText(node, texts.join("\n"));
             }
           });
         } else if (typeSpecifiers.length > 0) {
@@ -111,9 +117,9 @@ import { ${valueSpecifiersText} } from "${node.source.value}";`
   }
 });
 
-const RULE_NAME$2 = "no-useless-template-string";
+const RULE_NAME$1 = "no-useless-template-string";
 const noUselessTemplateString = createEslintRule({
-  name: RULE_NAME$2,
+  name: RULE_NAME$1,
   meta: {
     type: "problem",
     docs: {
@@ -127,32 +133,44 @@ const noUselessTemplateString = createEslintRule({
     }
   },
   defaultOptions: [],
-  create: (context) => {
-    return {
-      TemplateLiteral(node) {
-        const hasNewline = node.quasis.some((n) => n.value.raw.includes("\n"));
-        if (node.expressions.length === 0 && !hasNewline) {
-          context.report({
-            node,
-            messageId: "noUselessTemplateString",
-            fix(fixer) {
-              const s = node.range[0];
-              const e = node.range[1];
-              return fixer.replaceTextRange(
-                [s, e],
-                `"${node.quasis[0].value.raw}"`
-              );
-            }
-          });
-        }
+  create: (context) => ({
+    TemplateLiteral(node) {
+      const hasNewline = node.quasis.some((n) => n.value.raw.includes("\n"));
+      if (node.expressions.length === 0 && !hasNewline) {
+        context.report({
+          node,
+          messageId: "noUselessTemplateString",
+          fix(fixer) {
+            const s = node.range[0];
+            const e = node.range[1];
+            return fixer.replaceTextRange(
+              [s, e],
+              `"${node.quasis[0].value.raw}"`
+            );
+          }
+        });
       }
-    };
-  }
+    }
+  })
 });
 
-const RULE_NAME$1 = "pad-after-last-import";
-const padAfterLastImport = createEslintRule({
-  name: RULE_NAME$1,
+const RULE_NAME = "function-style";
+const START_RETURN = /^return /;
+const END_SEMICOLON = /;$/;
+function getBeforeNode(node) {
+  const { parent } = node;
+  if (!parent)
+    return;
+  const { body } = parent;
+  if (!body)
+    return;
+  const index = body.indexOf(node);
+  if (index === 0)
+    return;
+  return body[index - 1];
+}
+const functionStyle = createEslintRule({
+  name: RULE_NAME,
   meta: {
     type: "problem",
     docs: {
@@ -162,71 +180,88 @@ const padAfterLastImport = createEslintRule({
     fixable: "code",
     schema: [],
     messages: {
-      padAfterLastImport: "Expected a blank line after the last import."
+      arrow: "Expected an arrow function.",
+      arrowShorthand: "Expected an arrow function shorthand.",
+      declaration: "Expected a function declaration."
     }
   },
   defaultOptions: [],
   create: (context) => {
     const sourceCode = context.getSourceCode();
-    let lastImportNode = null;
+    const text = sourceCode.getText();
+    const getStatementRaw = (statement) => `(${text.slice(statement.range[0], statement.range[1]).replace(START_RETURN, "").replace(END_SEMICOLON, "")})`;
+    function getLonelyReturnStatement(node) {
+      const { body } = node;
+      if (body.type === AST_NODE_TYPES.BlockStatement) {
+        const { body: blockBody } = body;
+        if (blockBody.length === 1) {
+          const [statement] = blockBody;
+          if (statement?.type === AST_NODE_TYPES.ReturnStatement) {
+            return statement;
+          }
+        }
+      }
+    }
+    function generateFunction(node, type) {
+      const async = node.async ? "async " : "";
+      const params = node.params.map((param) => sourceCode.getText(param)).join(", ");
+      const generics = node.typeParameters ? sourceCode.getText(node.typeParameters) : "";
+      const body = sourceCode.getText(node.body);
+      return type === "arrow" ? `const ${node.id.name} = ${async}${generics}(${params}) => ${body};` : `${async}function ${node.parent.id.name}${generics}(${params}) ${body}`;
+    }
     return {
-      ImportDeclaration(node) {
-        lastImportNode = node;
+      FunctionDeclaration(node) {
+        if (!node.id?.name)
+          return;
+        const statement = getLonelyReturnStatement(node);
+        if (!statement || node.generator || getBeforeNode(node)?.type === AST_NODE_TYPES.TSDeclareFunction)
+          return;
+        context.report({
+          node,
+          messageId: "arrow",
+          fix: (fixer) => {
+            const [start, end] = node.range;
+            return fixer.replaceTextRange(
+              [start, end],
+              generateFunction(node, "arrow")
+            );
+          }
+        });
       },
-      "Program:exit"() {
-        if (lastImportNode) {
-          const nextToken = sourceCode.getTokenAfter(lastImportNode);
-          if (nextToken && // Workaround: Vue
-          nextToken.value !== "<\/script>" && lastImportNode.loc.end.line + 1 === nextToken.loc.start.line) {
+      ArrowFunctionExpression(node) {
+        const { body, parent } = node;
+        if (parent?.id?.typeAnnotation)
+          return;
+        if (body.type === AST_NODE_TYPES.BlockStatement) {
+          const { body: blockBody } = body;
+          if (blockBody.length > 1 && node.parent?.parent?.type === AST_NODE_TYPES.VariableDeclaration) {
+            const parent2 = node.parent.parent;
             context.report({
-              node: lastImportNode,
-              messageId: "padAfterLastImport",
-              fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
+              node: parent2,
+              messageId: "declaration",
+              fix: (fixer) => {
+                const [start, end] = parent2.range;
+                return fixer.replaceTextRange(
+                  [start, end],
+                  generateFunction(node, "declaration")
+                );
+              }
             });
           }
         }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "no-beginning-newline";
-const noBeginningNewline = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "No beginning newline",
-      recommended: "error"
-    },
-    fixable: "whitespace",
-    schema: [],
-    messages: {
-      noBeginningNewline: "No beginning newline"
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const text = context.getSourceCode().text;
-    return {
-      Program: (node) => {
-        const newlines = text.match(/([\n]*)/)[1];
-        if (newlines.length > 0) {
+        const statement = getLonelyReturnStatement(node);
+        if (statement)
           context.report({
             node,
-            loc: {
-              start: {
-                line: 0,
-                column: 0
-              },
-              end: node.loc.start
-            },
-            messageId: "noBeginningNewline",
-            *fix(fixer) {
-              yield fixer.removeRange([0, node.range[0]]);
+            messageId: "arrowShorthand",
+            fix: (fixer) => {
+              const [start, end] = node.body.range;
+              return fixer.replaceTextRange(
+                [start, end],
+                getStatementRaw(statement)
+              );
             }
           });
-        }
       }
     };
   }
@@ -237,8 +272,7 @@ const index = {
     "import-dedupe": importDedupe,
     "no-inline-type-import": noInlineTypeImport,
     "no-useless-template-string": noUselessTemplateString,
-    "no-beginning-newline": noBeginningNewline,
-    "pad-after-last-import": padAfterLastImport
+    "function-style": functionStyle
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "0.75.0",
+  "version": "0.77.0",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {
@@ -31,12 +31,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^5.58.0",
+    "@typescript-eslint/utils": "^5.59.2",
     "@vue/reactivity": "^3.2.47"
   },
   "devDependencies": {
-    "@types/node": "^18.15.11",
-    "@typescript-eslint/types": "^5.58.0"
+    "@types/node": "^18.16.5",
+    "@typescript-eslint/types": "^5.59.2"
   },
   "scripts": {
     "build": "unbuild",