@so1ve/eslint-plugin 0.75.0 → 0.76.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 const utils = require('@typescript-eslint/utils');
+const types = require('@typescript-eslint/types');
 
 const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
 
@@ -20,38 +21,36 @@ 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";
@@ -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) {
@@ -129,72 +135,30 @@ 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}"`
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$1 = "pad-after-last-import";
-const padAfterLastImport = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Pad after the last import.",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      padAfterLastImport: "Expected a blank line after the last import."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    let lastImportNode = null;
-    return {
-      ImportDeclaration(node) {
-        lastImportNode = node;
-      },
-      "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) {
-            context.report({
-              node: lastImportNode,
-              messageId: "padAfterLastImport",
-              fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
-            });
+  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 = "no-beginning-newline";
+const RULE_NAME$1 = "no-beginning-newline";
 const noBeginningNewline = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$1,
   meta: {
     type: "layout",
     docs: {
@@ -234,13 +198,126 @@ const noBeginningNewline = createEslintRule({
   }
 });
 
+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: {
+      description: "Pad after the last import.",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      arrow: "Expected an arrow function.",
+      arrowShorthand: "Expected an arrow function shorthand.",
+      declaration: "Expected a function declaration."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    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 {
+      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")
+            );
+          }
+        });
+      },
+      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: parent2,
+              messageId: "declaration",
+              fix: (fixer) => {
+                const [start, end] = parent2.range;
+                return fixer.replaceTextRange(
+                  [start, end],
+                  generateFunction(node, "declaration")
+                );
+              }
+            });
+          }
+        }
+        const statement = getLonelyReturnStatement(node);
+        if (statement)
+          context.report({
+            node,
+            messageId: "arrowShorthand",
+            fix: (fixer) => {
+              const [start, end] = node.body.range;
+              return fixer.replaceTextRange(
+                [start, end],
+                getStatementRaw(statement)
+              );
+            }
+          });
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "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,14 @@
 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,4 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
 
 const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 
@@ -18,38 +19,36 @@ 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";
@@ -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) {
@@ -127,72 +133,30 @@ 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}"`
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$1 = "pad-after-last-import";
-const padAfterLastImport = createEslintRule({
-  name: RULE_NAME$1,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Pad after the last import.",
-      recommended: "error"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      padAfterLastImport: "Expected a blank line after the last import."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.getSourceCode();
-    let lastImportNode = null;
-    return {
-      ImportDeclaration(node) {
-        lastImportNode = node;
-      },
-      "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) {
-            context.report({
-              node: lastImportNode,
-              messageId: "padAfterLastImport",
-              fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
-            });
+  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 = "no-beginning-newline";
+const RULE_NAME$1 = "no-beginning-newline";
 const noBeginningNewline = createEslintRule({
-  name: RULE_NAME,
+  name: RULE_NAME$1,
   meta: {
     type: "layout",
     docs: {
@@ -232,13 +196,126 @@ const noBeginningNewline = createEslintRule({
   }
 });
 
+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: {
+      description: "Pad after the last import.",
+      recommended: "error"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      arrow: "Expected an arrow function.",
+      arrowShorthand: "Expected an arrow function shorthand.",
+      declaration: "Expected a function declaration."
+    }
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const sourceCode = context.getSourceCode();
+    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 {
+      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")
+            );
+          }
+        });
+      },
+      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: parent2,
+              messageId: "declaration",
+              fix: (fixer) => {
+                const [start, end] = parent2.range;
+                return fixer.replaceTextRange(
+                  [start, end],
+                  generateFunction(node, "declaration")
+                );
+              }
+            });
+          }
+        }
+        const statement = getLonelyReturnStatement(node);
+        if (statement)
+          context.report({
+            node,
+            messageId: "arrowShorthand",
+            fix: (fixer) => {
+              const [start, end] = node.body.range;
+              return fixer.replaceTextRange(
+                [start, end],
+                getStatementRaw(statement)
+              );
+            }
+          });
+      }
+    };
+  }
+});
+
 const index = {
   rules: {
     "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.76.0",
   "author": "Anthony Fu <anthonyfu117@hotmail.com> (https://github.com/antfu/)",
   "contributors": [
     {