@debbl/eslint-config 1.1.1 → 1.2.0

package/dist/index.js

@@ -1,37 +1,14 @@
-// src/plugins.ts
-import { default as default2 } from "eslint-plugin-antfu";
-import { default as default3 } from "eslint-plugin-eslint-comments";
-import * as pluginImport from "eslint-plugin-i";
-import { default as default4 } from "eslint-plugin-jsdoc";
-import { default as default5 } from "eslint-plugin-markdown";
-import { default as default6 } from "eslint-plugin-n";
-import { default as default7 } from "eslint-plugin-unicorn";
-import { default as default8 } from "eslint-plugin-unused-imports";
-import { default as default9 } from "eslint-plugin-no-only-tests";
-import { default as default10 } from "eslint-plugin-vitest";
-import { default as default11 } from "eslint-plugin-perfectionist";
-import { default as default12 } from "eslint-plugin-prettier";
-import { default as default13 } from "eslint-config-prettier";
-import { default as default14 } from "eslint-plugin-react";
-import { default as default15 } from "eslint-plugin-react-hooks";
-import { default as default16 } from "@next/eslint-plugin-next";
-import * as parserTs from "@typescript-eslint/parser";
-import { default as default17 } from "@typescript-eslint/eslint-plugin";
-import { default as default18 } from "eslint-plugin-vue";
-import { default as default19 } from "vue-eslint-parser";
-import * as pluginYml from "eslint-plugin-yml";
-import { default as default20 } from "yaml-eslint-parser";
-import * as pluginJsonc from "eslint-plugin-jsonc";
-import { default as default21 } from "jsonc-eslint-parser";
-import { default as default22 } from "eslint-plugin-tailwindcss";
-
 // src/configs/comments.ts
-function comments() {
+async function comments() {
+  const pluginComments = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-eslint-comments")
+  );
   return [
     {
       name: "eslint:eslint-comments",
       plugins: {
-        "eslint-comments": default3
+        "eslint-comments": pluginComments
       },
       rules: {
         "eslint-comments/no-aggregating-enable": "error",
@@ -113,7 +90,7 @@ var GLOB_EXCLUDE = [
 // src/configs/ignores.ts
 var REGEX_SPLIT_ALL_CRLF = /\r?\n/g;
 var splitPattern = (pattern) => pattern.split(REGEX_SPLIT_ALL_CRLF);
-function ignores(options) {
+async function ignores(options) {
   const { enableGitignore } = options;
   if (enableGitignore) {
     let ignorePath = ".gitignore";
@@ -138,13 +115,28 @@ function ignores(options) {
   ];
 }
 
+// src/utils.ts
+async function combine(...configs) {
+  const resolved = await Promise.all(configs);
+  return resolved.flat();
+}
+async function interopDefault(m) {
+  const resolved = await m;
+  return resolved.default || resolved;
+}
+
 // src/configs/imports.ts
-function imports() {
+async function imports() {
+  const [pluginAntfu, pluginImport] = await Promise.all([
+    interopDefault(import("eslint-plugin-antfu")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-i"))
+  ]);
   return [
     {
       name: "eslint:imports",
       plugins: {
-        antfu: default2,
+        antfu: pluginAntfu,
         import: pluginImport
       },
       rules: {
@@ -168,9 +160,15 @@ function imports() {
 
 // src/configs/javascript.ts
 import globals from "globals";
-function javascript() {
+async function javascript() {
+  const [pluginAntfu, pluginUnusedImports] = await Promise.all([
+    interopDefault(import("eslint-plugin-antfu")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-unused-imports"))
+  ]);
   return [
     {
+      name: "eslint:javascript",
       languageOptions: {
         ecmaVersion: 2022,
         globals: {
@@ -193,10 +191,9 @@ function javascript() {
       linterOptions: {
         reportUnusedDisableDirectives: true
       },
-      name: "eslint:javascript",
       plugins: {
-        "antfu": default2,
-        "unused-imports": default8
+        "antfu": pluginAntfu,
+        "unused-imports": pluginUnusedImports
       },
       rules: {
         "accessor-pairs": [
@@ -408,8 +405,8 @@ function javascript() {
       }
     },
     {
-      files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
       name: "eslint:scripts-overrides",
+      files: [`scripts/${GLOB_SRC}`, `cli.${GLOB_SRC_EXT}`],
       rules: {
         "no-console": "off"
       }
@@ -418,12 +415,13 @@ function javascript() {
 }
 
 // src/configs/jsdoc.ts
-function jsdoc() {
+async function jsdoc() {
   return [
     {
       name: "eslint:jsdoc",
       plugins: {
-        jsdoc: default4
+        // @ts-expect-error missing types
+        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
       },
       rules: {
         "jsdoc/check-access": "warn",
@@ -449,7 +447,11 @@ function jsdoc() {
 }
 
 // src/configs/jsonc.ts
-function jsonc() {
+async function jsonc() {
+  const [pluginJsonc, parserJsonc] = await Promise.all([
+    interopDefault(import("eslint-plugin-jsonc")),
+    interopDefault(import("jsonc-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:jsonc:setup",
@@ -458,11 +460,11 @@ function jsonc() {
       }
     },
     {
+      name: "eslint:jsonc:rules",
       files: [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
       languageOptions: {
-        parser: default21
+        parser: parserJsonc
       },
-      name: "eslint:jsonc:rules",
       rules: {
         "jsonc/no-bigint-literals": "error",
         "jsonc/no-binary-expression": "error",
@@ -515,21 +517,23 @@ function jsonc() {
 }
 
 // src/configs/markdown.ts
-function markdown(options = {}) {
+async function markdown(options = {}) {
   const { componentExts = [] } = options;
   return [
     {
-      name: "antfu:markdown:setup",
+      name: "eslint:markdown:setup",
       plugins: {
-        markdown: default5
+        // @ts-expect-error missing types
+        markdown: await interopDefault(import("eslint-plugin-markdown"))
       }
     },
     {
+      name: "eslint:markdown:processor",
       files: [GLOB_MARKDOWN],
-      name: "antfu:markdown:processor",
       processor: "markdown/markdown"
     },
     {
+      name: "eslint:markdown:rules",
       files: [
         GLOB_MARKDOWN_CODE,
         ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
@@ -541,7 +545,6 @@ function markdown(options = {}) {
           }
         }
       },
-      name: "antfu:markdown:rules",
       rules: {
         "antfu/no-cjs-exports": "off",
         "antfu/no-ts-export-equal": "off",
@@ -588,12 +591,13 @@ function markdown(options = {}) {
 }
 
 // src/configs/node.ts
-function node() {
+async function node() {
+  const pluginNode = await interopDefault(import("eslint-plugin-n"));
   return [
     {
       name: "eslint:node",
       plugins: {
-        n: default6
+        n: pluginNode
       },
       rules: {
         "n/handle-callback-err": ["error", "^(err|error)$"],
@@ -610,11 +614,11 @@ function node() {
 }
 
 // src/configs/sort.ts
-function sortPackageJson() {
+async function sortPackageJson() {
   return [
     {
-      files: ["**/package.json"],
       name: "eslint:sort-package-json",
+      files: ["**/package.json"],
       rules: {
         "jsonc/sort-array-values": [
           "error",
@@ -694,11 +698,11 @@ function sortPackageJson() {
     }
   ];
 }
-function sortTsconfig() {
+async function sortTsconfig() {
   return [
     {
-      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
       name: "eslint:sort-tsconfig",
+      files: ["**/tsconfig.json", "**/tsconfig.*.json"],
       rules: {
         "jsonc/sort-keys": [
           "error",
@@ -822,44 +826,49 @@ function sortTsconfig() {
 
 // src/configs/typescript.ts
 import process2 from "process";
-function typescript(options) {
+var typeAwareRules = {
+  "dot-notation": "off",
+  "no-implied-eval": "off",
+  "no-throw-literal": "off",
+  "@typescript-eslint/await-thenable": "error",
+  "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+  "@typescript-eslint/no-floating-promises": "error",
+  "@typescript-eslint/no-for-in-array": "error",
+  "@typescript-eslint/no-implied-eval": "error",
+  "@typescript-eslint/no-misused-promises": "error",
+  "@typescript-eslint/no-throw-literal": "error",
+  "@typescript-eslint/no-unnecessary-type-assertion": "error",
+  "@typescript-eslint/no-unsafe-argument": "error",
+  "@typescript-eslint/no-unsafe-assignment": "error",
+  "@typescript-eslint/no-unsafe-call": "error",
+  "@typescript-eslint/no-unsafe-member-access": "error",
+  "@typescript-eslint/no-unsafe-return": "error",
+  "@typescript-eslint/restrict-plus-operands": "error",
+  "@typescript-eslint/restrict-template-expressions": "error",
+  "@typescript-eslint/unbound-method": "error"
+};
+async function typescript(options) {
   const {
     componentExts = [],
     parserOptions = {},
     tsconfigPath
   } = options ?? {};
-  const typeAwareRules = {
-    "dot-notation": "off",
-    "no-implied-eval": "off",
-    "no-throw-literal": "off",
-    "@typescript-eslint/await-thenable": "error",
-    "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
-    "@typescript-eslint/no-floating-promises": "error",
-    "@typescript-eslint/no-for-in-array": "error",
-    "@typescript-eslint/no-implied-eval": "error",
-    "@typescript-eslint/no-misused-promises": "error",
-    "@typescript-eslint/no-throw-literal": "error",
-    "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unsafe-argument": "error",
-    "@typescript-eslint/no-unsafe-assignment": "error",
-    "@typescript-eslint/no-unsafe-call": "error",
-    "@typescript-eslint/no-unsafe-member-access": "error",
-    "@typescript-eslint/no-unsafe-return": "error",
-    "@typescript-eslint/restrict-plus-operands": "error",
-    "@typescript-eslint/restrict-template-expressions": "error",
-    "@typescript-eslint/unbound-method": "error"
-  };
+  const [pluginTs, parserTs, pluginAntfu] = await Promise.all([
+    interopDefault(import("@typescript-eslint/eslint-plugin")),
+    interopDefault(import("@typescript-eslint/parser")),
+    interopDefault(import("eslint-plugin-antfu"))
+  ]);
   return [
     {
       // Install the plugins without globs, so they can be configured separately.
       name: "eslint:typescript:setup",
       plugins: {
-        "antfu": default2,
-        "import": pluginImport,
-        "@typescript-eslint": default17
+        "antfu": pluginAntfu,
+        "@typescript-eslint": pluginTs
       }
     },
     {
+      name: "eslint:typescript:rules",
       files: [GLOB_SRC, ...componentExts.map((ext) => `**/*.${ext}`)],
       languageOptions: {
         parser: parserTs,
@@ -873,10 +882,9 @@ function typescript(options) {
           ...parserOptions
         }
       },
-      name: "eslint:typescript:rules",
       rules: {
-        ...default17.configs["eslint-recommended"].overrides[0].rules,
-        ...default17.configs.strict.rules,
+        ...pluginTs.configs["eslint-recommended"].overrides[0].rules,
+        ...pluginTs.configs.strict.rules,
         "antfu/generic-spacing": "error",
         "antfu/named-tuple-spacing": "error",
         "antfu/no-cjs-exports": "error",
@@ -926,8 +934,8 @@ function typescript(options) {
       }
     },
     {
-      files: ["**/*.d.ts"],
       name: "eslint:typescript:dts-overrides",
+      files: ["**/*.d.ts"],
       rules: {
         "eslint-comments/no-unlimited-disable": "off",
         "import/no-duplicates": "off",
@@ -936,8 +944,8 @@ function typescript(options) {
       }
     },
     {
-      files: ["**/*.{test,spec}.ts?(x)"],
       name: "eslint:typescript:tests-overrides",
+      files: ["**/*.{test,spec}.ts?(x)"],
       rules: {
         "no-unused-expressions": "off"
       }
@@ -954,12 +962,13 @@ function typescript(options) {
 }
 
 // src/configs/unicorn.ts
-function unicorn() {
+async function unicorn() {
+  const pluginUnicorn = await interopDefault(import("eslint-plugin-unicorn"));
   return [
     {
       name: "eslint:unicorn",
       plugins: {
-        unicorn: default7
+        unicorn: pluginUnicorn
       },
       rules: {
         // Pass error message when throwing errors
@@ -994,34 +1003,41 @@ function unicorn() {
 }
 
 // src/configs/vue.ts
-function vue(options = {}) {
+async function vue(options = {}) {
+  const [pluginVue, parserVue] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-vue")),
+    interopDefault(import("vue-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:vue:setup",
       plugins: {
-        vue: default18
+        vue: pluginVue
       }
     },
     {
+      name: "eslint:vue:rules",
       files: [GLOB_VUE],
       languageOptions: {
-        parser: default19,
+        parser: parserVue,
         parserOptions: {
           ecmaFeatures: {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: options.typescript ? parserTs : null,
+          parser: options.typescript ? await interopDefault(
+            import("@typescript-eslint/parser")
+          ) : null,
           sourceType: "module"
         }
       },
-      name: "eslint:vue:rules",
-      processor: default18.processors[".vue"],
+      processor: pluginVue.processors[".vue"],
       rules: {
-        ...default18.configs.base.rules,
-        ...default18.configs["vue3-essential"].rules,
-        ...default18.configs["vue3-strongly-recommended"].rules,
-        ...default18.configs["vue3-recommended"].rules,
+        ...pluginVue.configs.base.rules,
+        ...pluginVue.configs["vue3-essential"].rules,
+        ...pluginVue.configs["vue3-strongly-recommended"].rules,
+        ...pluginVue.configs["vue3-recommended"].rules,
         "node/prefer-global/process": "off",
         "vue/block-order": [
           "error",
@@ -1127,7 +1143,11 @@ function vue(options = {}) {
 }
 
 // src/configs/yml.ts
-function yml() {
+async function yml() {
+  const [pluginYml, parserYml] = await Promise.all([
+    interopDefault(import("eslint-plugin-yml")),
+    interopDefault(import("yaml-eslint-parser"))
+  ]);
   return [
     {
       name: "eslint:yaml:setup",
@@ -1136,11 +1156,11 @@ function yml() {
       }
     },
     {
+      name: "eslint:yaml:rules",
       files: [GLOB_YAML],
       languageOptions: {
-        parser: default20
+        parser: parserYml
       },
-      name: "eslint:yaml:rules",
       rules: {
         ...pluginYml.configs.standard.rules,
         ...pluginYml.configs.prettier.rules,
@@ -1158,24 +1178,29 @@ function yml() {
 }
 
 // src/configs/test.ts
-function test() {
+async function test() {
+  const [pluginVitest, pluginNoOnlyTests] = await Promise.all([
+    interopDefault(import("eslint-plugin-vitest")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-no-only-tests"))
+  ]);
   return [
     {
       name: "eslint:test:setup",
       plugins: {
         test: {
-          ...default10,
+          ...pluginVitest,
           rules: {
-            ...default10.rules,
+            ...pluginVitest.rules,
             // extend `test/no-only-tests` rule
-            ...default9.rules
+            ...pluginNoOnlyTests.rules
           }
         }
       }
     },
     {
-      files: GLOB_TESTS,
       name: "eslint:test:rules",
+      files: GLOB_TESTS,
       rules: {
         "test/consistent-test-it": [
           "error",
@@ -1191,28 +1216,37 @@ function test() {
 }
 
 // src/configs/perfectionist.ts
-function perfectionist() {
+async function perfectionist() {
+  const pluginPerfectionist = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-perfectionist")
+  );
   return [
     {
       name: "eslint:perfectionist",
       plugins: {
-        perfectionist: default11
+        perfectionist: pluginPerfectionist
       }
     }
   ];
 }
 
 // src/configs/prettier.ts
-function prettier(options) {
+async function prettier(options) {
+  const [pluginPrettier, configPrettier] = await Promise.all([
+    interopDefault(import("eslint-plugin-prettier")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-config-prettier"))
+  ]);
   return [
     {
       name: "eslint:prettier",
       plugins: {
-        prettier: default12
+        prettier: pluginPrettier
       },
       rules: {
-        ...default13.rules,
-        ...default12.configs.recommended.rules,
+        ...configPrettier.rules,
+        ...pluginPrettier.configs.recommended.rules,
         "prettier/prettier": [
           "warn",
           {
@@ -1225,64 +1259,102 @@ function prettier(options) {
   ];
 }
 
-// src/utils.ts
-function combine(...configs) {
-  return configs.flat();
-}
-
 // src/configs/react.ts
-function next() {
+async function next() {
+  const pluginNext = await interopDefault(import("@next/eslint-plugin-next"));
   return [
     {
+      name: "eslint:next:setup",
       plugins: {
-        "@next/next": default16
+        "@next/next": pluginNext
+      }
+    },
+    {
+      name: "eslint:next:rules",
+      files: [GLOB_TSX, GLOB_JSX],
+      languageOptions: {
+        parserOptions: {
+          sourceType: "module",
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
       },
       rules: {
-        ...default16.configs.recommended.rules,
-        ...default16.configs["core-web-vitals"].rules
+        ...pluginNext.configs.recommended.rules,
+        ...pluginNext.configs["core-web-vitals"].rules
       }
     }
   ];
 }
-function react(options = {}) {
+async function react(options = {}) {
   const { next: enableNext = false } = options;
-  const _react = {
-    name: "eslint:react",
-    plugins: {
-      "react": default14,
-      "react-hooks": default15
-    },
-    settings: {
-      react: {
-        version: "18.0"
+  const [pluginReact, pluginReactHooks] = await Promise.all([
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-react")),
+    // @ts-expect-error missing types
+    interopDefault(import("eslint-plugin-react-hooks"))
+  ]);
+  const _react = [
+    {
+      name: "eslint:react:setup",
+      plugins: {
+        "react": pluginReact,
+        "react-hooks": pluginReactHooks
       }
     },
-    rules: {
-      ...default14.configs.recommended.rules,
-      ...default15.configs.recommended.rules,
-      "jsx-quotes": ["error", "prefer-double"],
-      "react/react-in-jsx-scope": "off",
-      "react/jsx-indent": [1, 2],
-      "react/jsx-indent-props": [1, 2],
-      "react/jsx-closing-bracket-location": [
-        1,
-        { selfClosing: "tag-aligned", nonEmpty: "tag-aligned" }
-      ]
+    {
+      name: "eslint:react:rules",
+      files: [GLOB_TSX, GLOB_JSX],
+      languageOptions: {
+        parserOptions: {
+          sourceType: "module",
+          ecmaFeatures: {
+            jsx: true
+          }
+        }
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      },
+      rules: {
+        ...pluginReact.configs.recommended.rules,
+        ...pluginReactHooks.configs.recommended.rules,
+        "jsx-quotes": ["error", "prefer-double"],
+        "react/react-in-jsx-scope": "off",
+        "react/jsx-indent": [1, 2],
+        "react/jsx-indent-props": [1, 2],
+        "react/jsx-closing-bracket-location": [
+          1,
+          { selfClosing: "tag-aligned", nonEmpty: "tag-aligned" }
+        ]
+      }
     }
-  };
+  ];
   return combine(_react, enableNext ? next() : []);
 }
 
 // src/configs/tailwindcss.ts
-function tailwindcss() {
+async function tailwindcss() {
+  const pluginTailwindcss = await interopDefault(
+    // @ts-expect-error missing types
+    import("eslint-plugin-tailwindcss")
+  );
   return [
     {
       name: "eslint:tailwindcss",
       plugins: {
-        tailwindcss: default22
+        tailwindcss: pluginTailwindcss
       },
       rules: {
-        ...default22.configs.recommended.rules
+        ...pluginTailwindcss.configs.recommended.rules
       }
     }
   ];
@@ -1388,40 +1460,16 @@ export {
   combine,
   comments,
   config,
-  default13 as configPrettier,
   src_default as default,
   ignores,
   imports,
+  interopDefault,
   javascript,
   jsdoc,
   jsonc,
   markdown,
   node,
-  default21 as parserJsonc,
-  parserTs,
-  default19 as parserVue,
-  default20 as parserYml,
   perfectionist,
-  default2 as pluginAntfu,
-  default3 as pluginComments,
-  pluginImport,
-  default4 as pluginJsdoc,
-  pluginJsonc,
-  default5 as pluginMarkdown,
-  default16 as pluginNext,
-  default9 as pluginNoOnlyTests,
-  default6 as pluginNode,
-  default11 as pluginPerfectionist,
-  default12 as pluginPrettier,
-  default14 as pluginReact,
-  default15 as pluginReactHooks,
-  default22 as pluginTailwindcss,
-  default17 as pluginTs,
-  default7 as pluginUnicorn,
-  default8 as pluginUnusedImports,
-  default10 as pluginVitest,
-  default18 as pluginVue,
-  pluginYml,
   prettier,
   sortPackageJson,
   sortTsconfig,