@so1ve/eslint-plugin 2.0.0 → 3.1.0

package/dist/index.d.ts

@@ -1,13 +1,17 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+type MessageIds = "arrow" | "declaration";
+
 declare const _default: {
     rules: {
-        "function-style": any;
-        "import-dedupe": any;
-        "no-inline-type-import": any;
-        "no-negated-comparison": any;
-        "no-useless-template-string": any;
-        "no-import-promises-as": any;
-        "pad-after-last-import": any;
-        "require-async-with-await": any;
+        "function-style": _typescript_eslint_utils_ts_eslint.RuleModule<MessageIds, [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "import-dedupe": _typescript_eslint_utils_ts_eslint.RuleModule<"importDedupe", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-inline-type-import": _typescript_eslint_utils_ts_eslint.RuleModule<"noInlineTypeImport", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-negated-comparison": _typescript_eslint_utils_ts_eslint.RuleModule<"noNegatedComparison", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-useless-template-string": _typescript_eslint_utils_ts_eslint.RuleModule<"noUselessTemplateString", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "no-import-promises-as": _typescript_eslint_utils_ts_eslint.RuleModule<"noImportPromisesAs", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "pad-after-last-import": _typescript_eslint_utils_ts_eslint.RuleModule<"padAfterLastImport", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
+        "require-async-with-await": _typescript_eslint_utils_ts_eslint.RuleModule<"requireAsyncWithAwait", [], _typescript_eslint_utils_ts_eslint.RuleListener>;
     };
 };
 

package/dist/{index.mjs → index.js}

@@ -1,7 +1,9 @@
-import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
-import { ESLintUtils } from '@typescript-eslint/utils';
+// src/rules/function-style.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 
-const createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
+// src/utils/index.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+var createEslintRule = ESLintUtils.RuleCreator((ruleName) => ruleName);
 function getPreviousNode(node) {
   if (!node) {
     return;
@@ -19,9 +21,10 @@ function getPreviousNode(node) {
   }
 }
 
-const RULE_NAME$7 = "function-style";
-const functionStyle = createEslintRule({
-  name: RULE_NAME$7,
+// src/rules/function-style.ts
+var RULE_NAME = "function-style";
+var function_style_default = createEslintRule({
+  name: RULE_NAME,
   meta: {
     type: "problem",
     docs: {
@@ -166,9 +169,10 @@ const functionStyle = createEslintRule({
   }
 });
 
-const RULE_NAME$6 = "import-dedupe";
-const importDedupe = createEslintRule({
-  name: RULE_NAME$6,
+// src/rules/import-dedupe.ts
+var RULE_NAME2 = "import-dedupe";
+var import_dedupe_default = createEslintRule({
+  name: RULE_NAME2,
   meta: {
     type: "problem",
     docs: {
@@ -215,14 +219,15 @@ const importDedupe = createEslintRule({
   })
 });
 
-const RULE_NAME$5 = "no-import-promises-as";
-const _POSSIBLE_IMPORT_SOURCES = ["dns", "fs", "readline", "stream"];
-const POSSIBLE_IMPORT_SOURCES = [
+// src/rules/no-import-promises-as.ts
+var RULE_NAME3 = "no-import-promises-as";
+var _POSSIBLE_IMPORT_SOURCES = ["dns", "fs", "readline", "stream"];
+var POSSIBLE_IMPORT_SOURCES = [
   ..._POSSIBLE_IMPORT_SOURCES,
   ..._POSSIBLE_IMPORT_SOURCES.map((s) => `node:${s}`)
 ];
-const noImportPromisesAs = createEslintRule({
-  name: RULE_NAME$5,
+var no_import_promises_as_default = createEslintRule({
+  name: RULE_NAME3,
   meta: {
     type: "problem",
     docs: {
@@ -273,9 +278,11 @@ import ${as} from "${node.source.value}/promises";`
   }
 });
 
-const RULE_NAME$4 = "no-inline-type-import";
-const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$4,
+// src/rules/no-inline-type-import.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
+var RULE_NAME4 = "no-inline-type-import";
+var no_inline_type_import_default = createEslintRule({
+  name: RULE_NAME4,
   meta: {
     type: "layout",
     docs: {
@@ -295,13 +302,13 @@ const noInlineTypeImport = createEslintRule({
       ImportDeclaration: (node) => {
         const { specifiers } = node;
         const typeSpecifiers = specifiers.filter(
-          (s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "type"
+          (s) => s.type === AST_NODE_TYPES2.ImportSpecifier && s.importKind === "type"
         );
         const valueSpecifiers = specifiers.filter(
-          (s) => s.type === AST_NODE_TYPES.ImportSpecifier && s.importKind === "value"
+          (s) => s.type === AST_NODE_TYPES2.ImportSpecifier && s.importKind === "value"
         );
         const defaultImportSpecifier = specifiers.find(
-          (s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier
+          (s) => s.type === AST_NODE_TYPES2.ImportDefaultSpecifier
         );
         if (typeSpecifiers.length > 0 && valueSpecifiers.length > 0) {
           context.report({
@@ -339,8 +346,10 @@ const noInlineTypeImport = createEslintRule({
   }
 });
 
-const RULE_NAME$3 = "no-negated-comparison";
-const negatedToPositive = {
+// src/rules/no-negated-comparison.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
+var RULE_NAME5 = "no-negated-comparison";
+var negatedToPositive = {
   "==": "!=",
   "===": "!==",
   "!=": "==",
@@ -350,9 +359,9 @@ const negatedToPositive = {
   ">": "<=",
   ">=": "<"
 };
-const negatives = Object.keys(negatedToPositive);
-const noNegatedComparison = createEslintRule({
-  name: RULE_NAME$3,
+var negatives = Object.keys(negatedToPositive);
+var no_negated_comparison_default = createEslintRule({
+  name: RULE_NAME5,
   meta: {
     type: "problem",
     docs: {
@@ -372,7 +381,7 @@ const noNegatedComparison = createEslintRule({
       if (!parent) {
         return;
       }
-      if (negatives.includes(operator) && parent.type === AST_NODE_TYPES.UnaryExpression && // Is this necessary?
+      if (negatives.includes(operator) && parent.type === AST_NODE_TYPES3.UnaryExpression && // Is this necessary?
       parent.operator === "!") {
         context.report({
           node,
@@ -389,9 +398,10 @@ const noNegatedComparison = createEslintRule({
   })
 });
 
-const RULE_NAME$2 = "no-useless-template-string";
-const noUselessTemplateString = createEslintRule({
-  name: RULE_NAME$2,
+// src/rules/no-useless-template-string.ts
+var RULE_NAME6 = "no-useless-template-string";
+var no_useless_template_string_default = createEslintRule({
+  name: RULE_NAME6,
   meta: {
     type: "problem",
     docs: {
@@ -427,9 +437,10 @@ const noUselessTemplateString = createEslintRule({
   })
 });
 
-const RULE_NAME$1 = "pad-after-last-import";
-const padAfterLastImport = createEslintRule({
-  name: RULE_NAME$1,
+// src/rules/pad-after-last-import.ts
+var RULE_NAME7 = "pad-after-last-import";
+var pad_after_last_import_default = createEslintRule({
+  name: RULE_NAME7,
   meta: {
     type: "problem",
     docs: {
@@ -457,7 +468,7 @@ const padAfterLastImport = createEslintRule({
           const expectedLine = lastImportNode.loc.end.line + 1;
           const nextTokenStartLine = nextToken?.loc.start.line;
           if (nextToken && // Workaround: Vue
-          nextToken.value !== "<\/script>" && (expectedLine === nextTokenStartLine || expectedLine === firstCommentAfterTokenStartLine)) {
+          nextToken.value !== "</script>" && (expectedLine === nextTokenStartLine || expectedLine === firstCommentAfterTokenStartLine)) {
             context.report({
               node: lastImportNode,
               messageId: "padAfterLastImport",
@@ -470,9 +481,11 @@ const padAfterLastImport = createEslintRule({
   }
 });
 
-const RULE_NAME = "require-async-with-await";
-const requireAsyncWithAwait = createEslintRule({
-  name: RULE_NAME,
+// src/rules/require-async-with-await.ts
+import { TSESTree } from "@typescript-eslint/types";
+var RULE_NAME8 = "require-async-with-await";
+var require_async_with_await_default = createEslintRule({
+  name: RULE_NAME8,
   meta: {
     type: "problem",
     docs: {
@@ -531,17 +544,19 @@ const requireAsyncWithAwait = createEslintRule({
   }
 });
 
-const index = {
+// src/index.ts
+var src_default = {
   rules: {
-    "function-style": functionStyle,
-    "import-dedupe": importDedupe,
-    "no-inline-type-import": noInlineTypeImport,
-    "no-negated-comparison": noNegatedComparison,
-    "no-useless-template-string": noUselessTemplateString,
-    "no-import-promises-as": noImportPromisesAs,
-    "pad-after-last-import": padAfterLastImport,
-    "require-async-with-await": requireAsyncWithAwait
+    "function-style": function_style_default,
+    "import-dedupe": import_dedupe_default,
+    "no-inline-type-import": no_inline_type_import_default,
+    "no-negated-comparison": no_negated_comparison_default,
+    "no-useless-template-string": no_useless_template_string_default,
+    "no-import-promises-as": no_import_promises_as_default,
+    "pad-after-last-import": pad_after_last_import_default,
+    "require-async-with-await": require_async_with_await_default
   }
 };
-
-export { index as default };
+export {
+  src_default as default
+};

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@so1ve/eslint-plugin",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "author": "Ray <i@mk1.io> (https://github.com/so1ve/)",
+  "type": "module",
   "keywords": [
     "eslint",
     "eslint-config",
@@ -16,8 +17,14 @@
     "url": "https://github.com/so1ve/codestyle-config/issues"
   },
   "license": "MIT",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
@@ -26,12 +33,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/types": "^7.1.0",
-    "@typescript-eslint/utils": "^7.1.0"
+    "@typescript-eslint/types": "^7.12.0",
+    "@typescript-eslint/utils": "^7.12.0"
   },
   "scripts": {
-    "build": "unbuild",
-    "stub": "unbuild --stub",
-    "test": "vitest"
+    "build": "tsup",
+    "test": "vitest",
+    "watch": "tsup --watch"
   }
 }

package/dist/index.cjs

@@ -1,549 +0,0 @@
-'use strict';
-
-const types = require('@typescript-eslint/types');
-const utils = require('@typescript-eslint/utils');
-
-const createEslintRule = utils.ESLintUtils.RuleCreator((ruleName) => ruleName);
-function getPreviousNode(node) {
-  if (!node) {
-    return;
-  }
-  const { parent } = node;
-  if (parent && "body" in parent) {
-    const { body } = parent;
-    if (!Array.isArray(body)) {
-      return;
-    }
-    const index = body.indexOf(node);
-    if (index > 0) {
-      return body[index - 1];
-    }
-  }
-}
-
-const RULE_NAME$7 = "function-style";
-const functionStyle = createEslintRule({
-  name: RULE_NAME$7,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforce function style.",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      arrow: "Expected an arrow function shorthand.",
-      declaration: "Expected a function declaration."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    function getLoneReturnStatement(node) {
-      const { body } = node;
-      if (body.type !== types.AST_NODE_TYPES.BlockStatement) {
-        return;
-      }
-      const { body: blockBody } = body;
-      const allComments = sourceCode.getCommentsInside(node);
-      if (blockBody.length !== 1) {
-        return;
-      }
-      const [statement] = blockBody;
-      const statementComments = sourceCode.getCommentsInside(statement);
-      if (allComments.length !== statementComments.length) {
-        return;
-      }
-      if (statement?.type === types.AST_NODE_TYPES.ReturnStatement) {
-        return statement;
-      }
-    }
-    function generateFunction(type, name, node, rawStatement, asVariable = true) {
-      const async = node.async ? "async " : "";
-      const generics = node.typeParameters ? sourceCode.getText(node.typeParameters) : "";
-      const params = node.params.map((param) => sourceCode.getText(param)).join(", ");
-      const returnType = node.returnType ? sourceCode.getText(node.returnType) : "";
-      const body = sourceCode.getText(node.body);
-      const variableDeclaration = asVariable && name ? `const ${name} = ` : "";
-      return type === "arrow" ? `${variableDeclaration}${async}${generics}(${params})${returnType} => ${rawStatement};` : `${async}function ${name}${generics}(${params})${returnType} ${body}`;
-    }
-    const scopeStack = [];
-    let haveThisAccess = false;
-    function setupScope(node) {
-      scopeStack.push(sourceCode.getScope(node));
-    }
-    function clearThisAccess() {
-      scopeStack.pop();
-      haveThisAccess = false;
-    }
-    return {
-      "FunctionExpression": setupScope,
-      "FunctionExpression:exit"(node) {
-        if (node.parent?.id?.typeAnnotation || node.parent?.type !== types.AST_NODE_TYPES.VariableDeclarator || haveThisAccess) {
-          clearThisAccess();
-          return;
-        }
-        const name = node.parent.id.name;
-        context.report({
-          node,
-          messageId: "declaration",
-          fix: (fixer) => fixer.replaceText(
-            node.parent.parent,
-            generateFunction("declaration", name, node)
-          )
-        });
-        clearThisAccess();
-      },
-      "FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration)": setupScope,
-      "FunctionDeclaration:not(TSDeclareFunction + FunctionDeclaration):exit"(node) {
-        if (haveThisAccess) {
-          return;
-        }
-        const previousNode = getPreviousNode(node.parent);
-        if (previousNode?.type === types.AST_NODE_TYPES.ExportNamedDeclaration && previousNode.declaration?.type === types.AST_NODE_TYPES.TSDeclareFunction) {
-          return;
-        }
-        const statement = getLoneReturnStatement(node);
-        const isExportDefault = node.parent?.type === types.AST_NODE_TYPES.ExportDefaultDeclaration;
-        if (!statement?.argument || !node.id?.name && !isExportDefault || node.generator) {
-          clearThisAccess();
-          return;
-        }
-        const returnVal = `(${sourceCode.getText(statement.argument)})`;
-        context.report({
-          node,
-          messageId: "arrow",
-          fix: (fixer) => fixer.replaceText(
-            node,
-            generateFunction(
-              "arrow",
-              node.id?.name ?? null,
-              node,
-              returnVal,
-              !isExportDefault
-            )
-          )
-        });
-        clearThisAccess();
-      },
-      "ArrowFunctionExpression": setupScope,
-      "ArrowFunctionExpression:exit"(node) {
-        if (haveThisAccess) {
-          return;
-        }
-        const { body, parent } = node;
-        const statement = getLoneReturnStatement(node);
-        if (statement?.argument) {
-          const returnVal = `(${sourceCode.getText(statement.argument)})`;
-          context.report({
-            node,
-            messageId: "arrow",
-            fix: (fixer) => fixer.replaceText(node.body, returnVal)
-          });
-        } else if (body.type === types.AST_NODE_TYPES.BlockStatement && !parent?.id?.typeAnnotation) {
-          const { body: blockBody } = body;
-          if (blockBody.length > 0 && node.parent?.parent?.type === types.AST_NODE_TYPES.VariableDeclaration) {
-            const { parent: grandParent } = node.parent;
-            context.report({
-              node: grandParent,
-              messageId: "declaration",
-              fix: (fixer) => fixer.replaceText(
-                grandParent,
-                generateFunction(
-                  "declaration",
-                  node.parent.id.name,
-                  node
-                )
-              )
-            });
-          }
-        }
-        clearThisAccess();
-      },
-      ThisExpression(node) {
-        haveThisAccess = scopeStack.includes(sourceCode.getScope(node));
-      }
-    };
-  }
-});
-
-const RULE_NAME$6 = "import-dedupe";
-const importDedupe = createEslintRule({
-  name: RULE_NAME$6,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Fix duplication in imports.",
-      recommended: "recommended"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      importDedupe: "Expect no duplication in imports."
-    }
-  },
-  defaultOptions: [],
-  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 start = n.range[0];
-              let end = n.range[1];
-              const nextToken = context.sourceCode.getTokenAfter(n);
-              if (nextToken && nextToken.value === ",") {
-                end = nextToken.range[1];
-              }
-              return fixer.removeRange([start, end]);
-            }
-          });
-        }
-        names.add(id);
-      }
-    }
-  })
-});
-
-const RULE_NAME$5 = "no-import-promises-as";
-const _POSSIBLE_IMPORT_SOURCES = ["dns", "fs", "readline", "stream"];
-const POSSIBLE_IMPORT_SOURCES = [
-  ..._POSSIBLE_IMPORT_SOURCES,
-  ..._POSSIBLE_IMPORT_SOURCES.map((s) => `node:${s}`)
-];
-const noImportPromisesAs = createEslintRule({
-  name: RULE_NAME$5,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow import promises as.",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      noImportPromisesAs: "Expect no import promises as."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const { text } = sourceCode;
-    return {
-      ImportDeclaration(node) {
-        if (!POSSIBLE_IMPORT_SOURCES.includes(node.source.value)) {
-          return;
-        }
-        const promisesSpecifier = node.specifiers.find(
-          (s) => s.type === "ImportSpecifier" && s.imported.name === "promises" && s.local.name !== "promises"
-        );
-        const as = promisesSpecifier?.local.name;
-        if (!promisesSpecifier || !as) {
-          return;
-        }
-        context.report({
-          node,
-          messageId: "noImportPromisesAs",
-          *fix(fixer) {
-            const s = promisesSpecifier.range[0];
-            let e = promisesSpecifier.range[1];
-            if (text[e] === ",") {
-              e += 1;
-            }
-            yield fixer.removeRange([s, e]);
-            yield fixer.insertTextAfter(
-              node,
-              `
-import ${as} from "${node.source.value}/promises";`
-            );
-          }
-        });
-      }
-    };
-  }
-});
-
-const RULE_NAME$4 = "no-inline-type-import";
-const noInlineTypeImport = createEslintRule({
-  name: RULE_NAME$4,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Disallow inline type import.",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      noInlineTypeImport: "Expected no inline type import."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    return {
-      ImportDeclaration: (node) => {
-        const { specifiers } = node;
-        const typeSpecifiers = specifiers.filter(
-          (s) => s.type === types.AST_NODE_TYPES.ImportSpecifier && s.importKind === "type"
-        );
-        const valueSpecifiers = specifiers.filter(
-          (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({
-            node,
-            messageId: "noInlineTypeImport",
-            fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              const valueSpecifiersText = valueSpecifiers.map((s) => sourceCode.getText(s)).join(", ");
-              const defaultImportSpecifierText = sourceCode.getText(
-                defaultImportSpecifier
-              );
-              const defaultAndValueSpecifiersText = defaultImportSpecifier ? `import ${defaultImportSpecifierText}, { ${valueSpecifiersText} } from "${node.source.value}";` : `import { ${valueSpecifiersText} } from "${node.source.value}";`;
-              const texts = [
-                `import type { ${typeSpecifiersText} } from "${node.source.value}";`,
-                defaultAndValueSpecifiersText
-              ];
-              return fixer.replaceText(node, texts.join("\n"));
-            }
-          });
-        } else if (typeSpecifiers.length > 0) {
-          context.report({
-            node,
-            messageId: "noInlineTypeImport",
-            fix(fixer) {
-              const typeSpecifiersText = typeSpecifiers.map((s) => sourceCode.getText(s).replace("type ", "")).join(", ");
-              return fixer.replaceText(
-                node,
-                `import type { ${typeSpecifiersText} } from "${node.source.value}";`
-              );
-            }
-          });
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME$3 = "no-negated-comparison";
-const negatedToPositive = {
-  "==": "!=",
-  "===": "!==",
-  "!=": "==",
-  "!==": "===",
-  "<": ">=",
-  "<=": ">",
-  ">": "<=",
-  ">=": "<"
-};
-const negatives = Object.keys(negatedToPositive);
-const noNegatedComparison = createEslintRule({
-  name: RULE_NAME$3,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow negated comparison.",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      noNegatedComparison: "Expect no negated comparison."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => ({
-    BinaryExpression(node) {
-      const { parent, left, right, operator } = node;
-      if (!parent) {
-        return;
-      }
-      if (negatives.includes(operator) && parent.type === types.AST_NODE_TYPES.UnaryExpression && // Is this necessary?
-      parent.operator === "!") {
-        context.report({
-          node,
-          messageId: "noNegatedComparison",
-          *fix(fixer) {
-            const operatorRange = [left.range[1], right.range[0]];
-            const fixedOperator = negatedToPositive[operator];
-            yield fixer.replaceTextRange(operatorRange, fixedOperator);
-            yield fixer.removeRange([parent.range[0], parent.range[0] + 1]);
-          }
-        });
-      }
-    }
-  })
-});
-
-const RULE_NAME$2 = "no-useless-template-string";
-const noUselessTemplateString = createEslintRule({
-  name: RULE_NAME$2,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "No useless template string.",
-      recommended: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      noUselessTemplateString: "No useless template string."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => ({
-    "TemplateLiteral:not(TaggedTemplateExpression > TemplateLiteral)"(node) {
-      const { quasis } = node;
-      const isSafe = !quasis.some(
-        ({ value: { raw } }) => raw.includes('"') || raw.includes("'") || raw.includes("\n")
-      );
-      if (node.expressions.length === 0 && isSafe) {
-        context.report({
-          node,
-          messageId: "noUselessTemplateString",
-          fix(fixer) {
-            return fixer.replaceTextRange(
-              node.range,
-              `"${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: "stylistic"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      padAfterLastImport: "Expected a blank line after the last import."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    let lastImportNode = null;
-    return {
-      ImportDeclaration(node) {
-        lastImportNode = node;
-      },
-      "Program:exit"() {
-        if (lastImportNode) {
-          const nextToken = sourceCode.getTokenAfter(lastImportNode);
-          const firstCommentAfterTokenStartLine = sourceCode.getCommentsAfter(lastImportNode)[0]?.loc.start.line;
-          const expectedLine = lastImportNode.loc.end.line + 1;
-          const nextTokenStartLine = nextToken?.loc.start.line;
-          if (nextToken && // Workaround: Vue
-          nextToken.value !== "<\/script>" && (expectedLine === nextTokenStartLine || expectedLine === firstCommentAfterTokenStartLine)) {
-            context.report({
-              node: lastImportNode,
-              messageId: "padAfterLastImport",
-              fix: (fixer) => fixer.insertTextAfter(lastImportNode, "\n")
-            });
-          }
-        }
-      }
-    };
-  }
-});
-
-const RULE_NAME = "require-async-with-await";
-const requireAsyncWithAwait = createEslintRule({
-  name: RULE_NAME,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require using async keyword with await.",
-      recommended: "recommended"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      requireAsyncWithAwait: "Expect using async keyword with await."
-    }
-  },
-  defaultOptions: [],
-  create: (context) => {
-    const functionNodeStack = [];
-    function setupNode(node) {
-      functionNodeStack.push(node);
-    }
-    function clearNode() {
-      functionNodeStack.pop();
-    }
-    return {
-      "FunctionExpression": setupNode,
-      "FunctionExpression:exit": clearNode,
-      "FunctionDeclaration": setupNode,
-      "FunctionDeclaration:exit": clearNode,
-      "ArrowFunctionExpression": setupNode,
-      "ArrowFunctionExpression:exit": clearNode,
-      AwaitExpression() {
-        const node = functionNodeStack[functionNodeStack.length - 1];
-        if (!node || node.async) {
-          return;
-        }
-        let fixRange;
-        if (node.type === types.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
-          fixRange = node.range;
-        }
-        if (node.type === types.TSESTree.AST_NODE_TYPES.FunctionDeclaration || node.type === types.TSESTree.AST_NODE_TYPES.FunctionExpression) {
-          if (node.parent.type === types.TSESTree.AST_NODE_TYPES.Property || node.parent.type === types.TSESTree.AST_NODE_TYPES.MethodDefinition) {
-            if (node.parent.kind === "method" || node.parent.kind === "init") {
-              fixRange = node.parent.key.range;
-            }
-          } else {
-            fixRange = node.range;
-          }
-        }
-        if (fixRange) {
-          context.report({
-            node,
-            messageId: "requireAsyncWithAwait",
-            fix: (fixer) => fixer.insertTextBeforeRange(fixRange, "async ")
-          });
-        }
-      }
-    };
-  }
-});
-
-const index = {
-  rules: {
-    "function-style": functionStyle,
-    "import-dedupe": importDedupe,
-    "no-inline-type-import": noInlineTypeImport,
-    "no-negated-comparison": noNegatedComparison,
-    "no-useless-template-string": noUselessTemplateString,
-    "no-import-promises-as": noImportPromisesAs,
-    "pad-after-last-import": padAfterLastImport,
-    "require-async-with-await": requireAsyncWithAwait
-  }
-};
-
-module.exports = index;

package/dist/index.d.cts

@@ -1,14 +0,0 @@
-declare const _default: {
-    rules: {
-        "function-style": any;
-        "import-dedupe": any;
-        "no-inline-type-import": any;
-        "no-negated-comparison": any;
-        "no-useless-template-string": any;
-        "no-import-promises-as": any;
-        "pad-after-last-import": any;
-        "require-async-with-await": any;
-    };
-};
-
-export { _default as default };

package/dist/index.d.mts

@@ -1,14 +0,0 @@
-declare const _default: {
-    rules: {
-        "function-style": any;
-        "import-dedupe": any;
-        "no-inline-type-import": any;
-        "no-negated-comparison": any;
-        "no-useless-template-string": any;
-        "no-import-promises-as": any;
-        "pad-after-last-import": any;
-        "require-async-with-await": any;
-    };
-};
-
-export { _default as default };