@coderwyd/eslint-config 1.1.0 → 2.0.0

package/dist/index.cjs

@@ -30,63 +30,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  GLOB_ALL_SRC: () => GLOB_ALL_SRC,
-  GLOB_CSS: () => GLOB_CSS,
-  GLOB_EXCLUDE: () => GLOB_EXCLUDE,
-  GLOB_HTML: () => GLOB_HTML,
-  GLOB_JS: () => GLOB_JS,
-  GLOB_JSON: () => GLOB_JSON,
-  GLOB_JSON5: () => GLOB_JSON5,
-  GLOB_JSONC: () => GLOB_JSONC,
-  GLOB_JSX: () => GLOB_JSX,
-  GLOB_LESS: () => GLOB_LESS,
-  GLOB_MARKDOWN: () => GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE: () => GLOB_MARKDOWN_CODE,
-  GLOB_SCSS: () => GLOB_SCSS,
-  GLOB_SRC: () => GLOB_SRC,
-  GLOB_SRC_EXT: () => GLOB_SRC_EXT,
-  GLOB_STYLE: () => GLOB_STYLE,
-  GLOB_TESTS: () => GLOB_TESTS,
-  GLOB_TS: () => GLOB_TS,
-  GLOB_TSX: () => GLOB_TSX,
-  GLOB_VUE: () => GLOB_VUE,
-  GLOB_YAML: () => GLOB_YAML,
-  coderwyd: () => coderwyd,
-  combine: () => combine,
-  comments: () => comments,
-  default: () => src_default,
-  ensurePackages: () => ensurePackages,
-  getVueVersion: () => getVueVersion,
-  ignores: () => ignores,
-  imports: () => imports,
-  interopDefault: () => interopDefault,
-  javascript: () => javascript,
-  jsdoc: () => jsdoc,
-  jsonc: () => jsonc,
-  markdown: () => markdown,
-  node: () => node,
-  perfectionist: () => perfectionist,
-  react: () => react,
-  renameRules: () => renameRules,
-  sortPackageJson: () => sortPackageJson,
-  sortTsconfig: () => sortTsconfig,
-  stylistic: () => stylistic,
-  test: () => test,
-  toArray: () => toArray,
-  typescript: () => typescript,
-  unicorn: () => unicorn,
-  unocss: () => unocss,
-  vue: () => vue,
-  yaml: () => yaml
+  defineConfig: () => defineConfig
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/factory.ts
 var import_node_process3 = __toESM(require("process"), 1);
 var import_node_fs = __toESM(require("fs"), 1);
 var import_local_pkg3 = require("local-pkg");
 
-// src/plugins.ts
+// src/constants/prettier.ts
+var DEFAULT_PRETTIER_RULES = {
+  arrowParens: "avoid",
+  htmlWhitespaceSensitivity: "ignore",
+  printWidth: 80,
+  semi: false,
+  singleQuote: true
+};
+
+// src/plugins/index.ts
 var import_eslint_plugin_antfu = __toESM(require("eslint-plugin-antfu"), 1);
 var import_eslint_plugin_eslint_comments = __toESM(require("eslint-plugin-eslint-comments"), 1);
 var pluginImport = __toESM(require("eslint-plugin-i"), 1);
@@ -113,24 +73,26 @@ async function comments() {
   ];
 }
 
-// src/globs.ts
+// src/constants/glob.ts
 var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
 var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
-var GLOB_JS = "**/*.?([cm])js";
 var GLOB_JSX = "**/*.?([cm])jsx";
 var GLOB_TS = "**/*.?([cm])ts";
 var GLOB_TSX = "**/*.?([cm])tsx";
-var GLOB_STYLE = "**/*.{c,le,sc}ss";
+var GLOB_VUE = "**/*.vue";
+var GLOB_HTML = "**/*.htm?(l)";
 var GLOB_CSS = "**/*.css";
+var GLOB_POSTCSS = "**/*.{p,post}css";
 var GLOB_LESS = "**/*.less";
 var GLOB_SCSS = "**/*.scss";
 var GLOB_JSON = "**/*.json";
 var GLOB_JSON5 = "**/*.json5";
 var GLOB_JSONC = "**/*.jsonc";
 var GLOB_MARKDOWN = "**/*.md";
-var GLOB_VUE = "**/*.vue";
 var GLOB_YAML = "**/*.y?(a)ml";
-var GLOB_HTML = "**/*.htm?(l)";
+var GLOB_TOML = "**/*.toml";
+var GLOB_GRAPHQL = "**/*.graphql";
+var GLOB_PRETTIER_LINT = [GLOB_SRC, GLOB_VUE];
 var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
 var GLOB_TESTS = [
   `**/__tests__/**/*.${GLOB_SRC_EXT}`,
@@ -139,16 +101,6 @@ var GLOB_TESTS = [
   `**/*.bench.${GLOB_SRC_EXT}`,
   `**/*.benchmark.${GLOB_SRC_EXT}`
 ];
-var GLOB_ALL_SRC = [
-  GLOB_SRC,
-  GLOB_STYLE,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_MARKDOWN,
-  GLOB_VUE,
-  GLOB_YAML,
-  GLOB_HTML
-];
 var GLOB_EXCLUDE = [
   "**/node_modules",
   "**/dist",
@@ -190,10 +142,7 @@ async function ignores() {
 }
 
 // src/configs/imports.ts
-async function imports(options = {}) {
-  const {
-    stylistic: stylistic2 = true
-  } = options;
+async function imports() {
   return [
     {
       name: "coderwyd:imports",
@@ -203,17 +152,61 @@ async function imports(options = {}) {
       },
       rules: {
         "antfu/import-dedupe": "error",
+        "antfu/no-import-dist": "error",
         "antfu/no-import-node-modules-by-path": "error",
         "import/first": "error",
+        "import/newline-after-import": [
+          "error",
+          { considerComments: true, count: 1 }
+        ],
+        "import/no-default-export": "error",
         "import/no-duplicates": "error",
         "import/no-mutable-exports": "error",
         "import/no-named-default": "error",
         "import/no-self-import": "error",
         "import/no-webpack-loader-syntax": "error",
-        "import/order": "error",
-        ...stylistic2 ? {
-          "import/newline-after-import": ["error", { considerComments: true, count: 1 }]
-        } : {}
+        "import/order": [
+          "error",
+          {
+            groups: [
+              "builtin",
+              "external",
+              "internal",
+              "parent",
+              "sibling",
+              "index",
+              "object",
+              "type"
+            ],
+            pathGroups: [{ group: "internal", pattern: "{{@,~}/,#}**" }],
+            pathGroupsExcludedImportTypes: ["type"]
+          }
+        ]
+      }
+    },
+    {
+      files: [
+        `**/*config*.${GLOB_SRC_EXT}`,
+        `**/views/${GLOB_SRC}`,
+        `**/pages/${GLOB_SRC}`,
+        `**/{index,vite,esbuild,rollup,webpack,rspack}.ts`,
+        "**/*.d.ts",
+        `${GLOB_MARKDOWN}/**`,
+        "**/.prettierrc*"
+      ],
+      plugins: {
+        import: pluginImport
+      },
+      rules: {
+        "import/no-default-export": "off"
+      }
+    },
+    {
+      files: ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
+      name: "antfu:imports:bin",
+      rules: {
+        "antfu/no-import-dist": "off",
+        "antfu/no-import-node-modules-by-path": "off"
       }
     }
   ];
@@ -222,10 +215,7 @@ async function imports(options = {}) {
 // src/configs/javascript.ts
 var import_globals = __toESM(require("globals"), 1);
 async function javascript(options = {}) {
-  const {
-    isInEditor = false,
-    overrides = {}
-  } = options;
+  const { isInEditor = false, overrides = {} } = options;
   return [
     {
       languageOptions: {
@@ -252,18 +242,23 @@ async function javascript(options = {}) {
       },
       name: "coderwyd:javascript",
       plugins: {
-        "antfu": import_eslint_plugin_antfu.default,
         "unused-imports": import_eslint_plugin_unused_imports.default
       },
       rules: {
-        "accessor-pairs": ["error", { enforceForClassMembers: true, setWithoutGet: true }],
+        "accessor-pairs": [
+          "error",
+          { enforceForClassMembers: true, setWithoutGet: true }
+        ],
         "array-callback-return": "error",
         "block-scoped-var": "error",
         "constructor-super": "error",
         "default-case-last": "error",
         "dot-notation": ["error", { allowKeywords: true }],
-        "eqeqeq": ["error", "smart"],
-        "new-cap": ["error", { capIsNew: false, newIsCap: true, properties: true }],
+        eqeqeq: ["error", "smart"],
+        "new-cap": [
+          "error",
+          { capIsNew: false, newIsCap: true, properties: true }
+        ],
         "no-alert": "error",
         "no-array-constructor": "error",
         "no-async-promise-executor": "error",
@@ -321,11 +316,26 @@ async function javascript(options = {}) {
         ],
         "no-restricted-properties": [
           "error",
-          { message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.", property: "__proto__" },
-          { message: "Use `Object.defineProperty` instead.", property: "__defineGetter__" },
-          { message: "Use `Object.defineProperty` instead.", property: "__defineSetter__" },
-          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupGetter__" },
-          { message: "Use `Object.getOwnPropertyDescriptor` instead.", property: "__lookupSetter__" }
+          {
+            message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+            property: "__proto__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineGetter__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineSetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupGetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupSetter__"
+          }
         ],
         "no-restricted-syntax": [
           "error",
@@ -352,18 +362,27 @@ async function javascript(options = {}) {
         "no-unreachable-loop": "error",
         "no-unsafe-finally": "error",
         "no-unsafe-negation": "error",
-        "no-unused-expressions": ["error", {
-          allowShortCircuit: true,
-          allowTaggedTemplates: true,
-          allowTernary: true
-        }],
-        "no-unused-vars": ["error", {
-          args: "none",
-          caughtErrors: "none",
-          ignoreRestSiblings: true,
-          vars: "all"
-        }],
-        "no-use-before-define": ["error", { classes: false, functions: false, variables: true }],
+        "no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "no-unused-vars": [
+          "error",
+          {
+            args: "none",
+            caughtErrors: "none",
+            ignoreRestSiblings: true,
+            vars: "all"
+          }
+        ],
+        "no-use-before-define": [
+          "error",
+          { classes: false, functions: false, variables: true }
+        ],
         "no-useless-backreference": "error",
         "no-useless-call": "error",
         "no-useless-catch": "error",
@@ -417,12 +436,20 @@ async function javascript(options = {}) {
         "unused-imports/no-unused-imports": isInEditor ? "off" : "error",
         "unused-imports/no-unused-vars": [
           "error",
-          { args: "after-used", argsIgnorePattern: "^_", vars: "all", varsIgnorePattern: "^_" }
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "use-isnan": [
+          "error",
+          { enforceForIndexOf: true, enforceForSwitchCase: true }
         ],
-        "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
         "valid-typeof": ["error", { requireStringLiterals: true }],
         "vars-on-top": "error",
-        "yoda": ["error", "never"],
+        yoda: ["error", "never"],
         ...overrides
       }
     },
@@ -436,9 +463,31 @@ async function javascript(options = {}) {
   ];
 }
 
-// src/utils.ts
+// src/shared/index.ts
 var import_node_process = __toESM(require("process"), 1);
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
 var import_local_pkg = require("local-pkg");
+var parserPlain = {
+  meta: {
+    name: "parser-plain"
+  },
+  parseForESLint: (code) => ({
+    ast: {
+      body: [],
+      comments: [],
+      loc: { end: code.length, start: 0 },
+      range: [0, code.length],
+      tokens: [],
+      type: "Program"
+    },
+    scopeManager: null,
+    services: { isPlain: true },
+    visitorKeys: {
+      Program: []
+    }
+  })
+};
 async function combine(...configs) {
   const resolved = await Promise.all(configs);
   return resolved.flat();
@@ -474,20 +523,41 @@ async function ensurePackages(packages) {
   const { default: prompts } = await import("prompts");
   const { result } = await prompts([
     {
-      message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?`,
+      message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(
+        ", "
+      )}. Do you want to install them?`,
       name: "result",
       type: "confirm"
     }
   ]);
   if (result)
-    await import("@antfu/install-pkg").then((i) => i.installPackage(nonExistingPackages, { dev: true }));
+    await import("@antfu/install-pkg").then(
+      (i) => i.installPackage(nonExistingPackages, { dev: true })
+    );
+}
+async function loadPrettierConfig(cwd) {
+  let prettierConfig = {};
+  try {
+    const prettierrc = await (0, import_promises.readFile)(import_node_path.default.join(cwd, ".prettierrc"), "utf-8");
+    prettierConfig = JSON.parse(prettierrc);
+  } catch {
+  }
+  return prettierConfig;
+}
+function resolveSubOptions(options, key) {
+  return typeof options[key] === "boolean" ? {} : options[key] || {};
+}
+function getOverrides(options, key) {
+  var _a;
+  const sub = resolveSubOptions(options, key);
+  return {
+    ...(_a = options.overrides) == null ? void 0 : _a[key],
+    ..."overrides" in sub ? sub.overrides : {}
+  };
 }
 
 // src/configs/jsdoc.ts
-async function jsdoc(options = {}) {
-  const {
-    stylistic: stylistic2 = true
-  } = options;
+async function jsdoc() {
   return [
     {
       name: "coderwyd:jsdoc",
@@ -510,11 +580,12 @@ async function jsdoc(options = {}) {
         "jsdoc/require-property-name": "warn",
         "jsdoc/require-returns-check": "warn",
         "jsdoc/require-returns-description": "warn",
-        "jsdoc/require-yields-check": "warn",
-        ...stylistic2 ? {
-          "jsdoc/check-alignment": "warn",
-          "jsdoc/multiline-blocks": "warn"
-        } : {}
+        "jsdoc/require-yields-check": "warn"
+        // style
+        // ...{
+        //   'jsdoc/check-alignment': 'warn',
+        // 'jsdoc/multiline-blocks': 'warn',
+        // }
       }
     }
   ];
@@ -522,18 +593,8 @@ async function jsdoc(options = {}) {
 
 // src/configs/jsonc.ts
 async function jsonc(options = {}) {
-  const {
-    files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC],
-    overrides = {},
-    stylistic: stylistic2 = true
-  } = options;
-  const {
-    indent = 2
-  } = typeof stylistic2 === "boolean" ? {} : stylistic2;
-  const [
-    pluginJsonc,
-    parserJsonc
-  ] = await Promise.all([
+  const { files = [GLOB_JSON, GLOB_JSON5, GLOB_JSONC], overrides = {} } = options || {};
+  const [pluginJsonc, parserJsonc] = await Promise.all([
     interopDefault(import("eslint-plugin-jsonc")),
     interopDefault(import("jsonc-eslint-parser"))
   ]);
@@ -577,101 +638,19 @@ async function jsonc(options = {}) {
         "jsonc/space-unary-ops": "error",
         "jsonc/valid-json-number": "error",
         "jsonc/vue-custom-block/no-parsing-error": "error",
-        ...stylistic2 ? {
-          "jsonc/array-bracket-spacing": ["error", "never"],
-          "jsonc/comma-dangle": ["error", "never"],
-          "jsonc/comma-style": ["error", "last"],
-          "jsonc/indent": ["error", indent],
-          "jsonc/key-spacing": ["error", { afterColon: true, beforeColon: false }],
-          "jsonc/object-curly-newline": ["error", { consistent: true, multiline: true }],
-          "jsonc/object-curly-spacing": ["error", "always"],
-          "jsonc/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
-          "jsonc/quote-props": "error",
-          "jsonc/quotes": "error"
-        } : {},
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/configs/markdown.ts
-async function markdown(options = {}) {
-  const {
-    componentExts = [],
-    files = [GLOB_MARKDOWN],
-    overrides = {}
-  } = options;
-  return [
-    {
-      name: "coderwyd:markdown:setup",
-      plugins: {
-        // @ts-expect-error missing types
-        markdown: await interopDefault(import("eslint-plugin-markdown"))
-      }
-    },
-    {
-      files,
-      name: "coderwyd:markdown:processor",
-      processor: "markdown/markdown"
-    },
-    {
-      files: [
-        GLOB_MARKDOWN_CODE,
-        ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
-      ],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            impliedStrict: true
-          }
-        }
-      },
-      name: "coderwyd:markdown:rules",
-      rules: {
-        "antfu/no-ts-export-equal": "off",
-        "import/newline-after-import": "off",
-        "no-alert": "off",
-        "no-console": "off",
-        "no-labels": "off",
-        "no-lone-blocks": "off",
-        "no-restricted-syntax": "off",
-        "no-undef": "off",
-        "no-unused-expressions": "off",
-        "no-unused-labels": "off",
-        "no-unused-vars": "off",
-        "node/prefer-global/process": "off",
-        "style/comma-dangle": "off",
-        "style/eol-last": "off",
-        "ts/consistent-type-imports": "off",
-        "ts/no-namespace": "off",
-        "ts/no-redeclare": "off",
-        "ts/no-require-imports": "off",
-        "ts/no-unused-vars": "off",
-        "ts/no-use-before-define": "off",
-        "ts/no-var-requires": "off",
-        "unicode-bom": "off",
-        "unused-imports/no-unused-imports": "off",
-        "unused-imports/no-unused-vars": "off",
-        // Type aware rules
-        ...{
-          "ts/await-thenable": "off",
-          "ts/dot-notation": "off",
-          "ts/no-floating-promises": "off",
-          "ts/no-for-in-array": "off",
-          "ts/no-implied-eval": "off",
-          "ts/no-misused-promises": "off",
-          "ts/no-throw-literal": "off",
-          "ts/no-unnecessary-type-assertion": "off",
-          "ts/no-unsafe-argument": "off",
-          "ts/no-unsafe-assignment": "off",
-          "ts/no-unsafe-call": "off",
-          "ts/no-unsafe-member-access": "off",
-          "ts/no-unsafe-return": "off",
-          "ts/restrict-plus-operands": "off",
-          "ts/restrict-template-expressions": "off",
-          "ts/unbound-method": "off"
-        },
+        // style
+        // ...{
+        //       'jsonc/array-bracket-spacing': ['error', 'never'],
+        //       'jsonc/comma-dangle': ['error', 'never'],
+        //       'jsonc/comma-style': ['error', 'last'],
+        //       'jsonc/indent': ['error', indent],
+        //       'jsonc/key-spacing': ['error', { afterColon: true, beforeColon: false }],
+        //       'jsonc/object-curly-newline': ['error', { consistent: true, multiline: true }],
+        //       'jsonc/object-curly-spacing': ['error', 'always'],
+        //       'jsonc/object-property-newline': ['error', { allowMultiplePropertiesPerLine: true }],
+        //       'jsonc/quote-props': 'error',
+        //       'jsonc/quotes': 'error',
+        //     },
         ...overrides
       }
     }
@@ -766,23 +745,14 @@ async function sortPackageJson() {
           },
           {
             order: { type: "asc" },
-            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$"
+            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$"
           },
           {
             order: { type: "asc" },
-            pathPattern: "^resolutions$"
+            pathPattern: "^(?:resolutions|overrides|pnpm.overrides)$"
           },
           {
-            order: { type: "asc" },
-            pathPattern: "^pnpm.overrides$"
-          },
-          {
-            order: [
-              "types",
-              "import",
-              "require",
-              "default"
-            ],
+            order: ["types", "import", "require", "default"],
             pathPattern: "^exports.*$"
           }
         ]
@@ -916,54 +886,40 @@ function sortTsconfig() {
   ];
 }
 
-// src/configs/stylistic.ts
-async function stylistic(options = {}) {
-  const {
-    indent = 2,
-    jsx = true,
-    quotes = "single",
-    semi = false
-  } = options;
-  const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
-  const config = pluginStylistic.configs.customize({
-    flat: true,
-    indent,
-    jsx,
-    pluginName: "style",
-    quotes,
-    semi
-  });
-  return [
+// src/configs/prettier.ts
+var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"), 1);
+var { rules: eslintRules } = import_eslint_config_prettier.default;
+async function prettier(rules) {
+  const pluginPrettier = await interopDefault(import("eslint-plugin-prettier"));
+  const pRules = {
+    ...rules
+  };
+  const configs = [
     {
-      name: "coderwyd:stylistic",
+      files: GLOB_PRETTIER_LINT,
       plugins: {
-        antfu: import_eslint_plugin_antfu.default,
-        style: pluginStylistic
+        prettier: pluginPrettier
       },
       rules: {
-        ...config.rules,
-        "antfu/consistent-list-newline": "error",
-        "antfu/if-newline": "error",
-        "antfu/indent-binary-ops": ["error", { indent }],
-        "antfu/top-level-function": "error",
-        "curly": ["error", "multi-or-nest", "consistent"]
+        ...eslintRules,
+        "arrow-body-style": "off",
+        "prefer-arrow-callback": "off",
+        "prettier/prettier": ["warn", pRules]
       }
     }
   ];
+  return configs;
 }
 
 // src/configs/typescript.ts
 var import_node_process2 = __toESM(require("process"), 1);
 async function typescript(options = {}) {
-  const {
-    componentExts = [],
-    overrides = {},
-    parserOptions = {}
-  } = options;
+  const { componentExts = [], overrides = {}, parserOptions = {} } = options;
   const files = options.files ?? [
     GLOB_SRC,
     ...componentExts.map((ext) => `**/*.${ext}`)
   ];
+  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
   const typeAwareRules = {
     "dot-notation": "off",
     "no-implied-eval": "off",
@@ -985,11 +941,8 @@ async function typescript(options = {}) {
     "ts/restrict-template-expressions": "error",
     "ts/unbound-method": "error"
   };
-  const tsconfigPath = options?.tsconfigPath ? toArray(options.tsconfigPath) : void 0;
-  const [
-    pluginTs,
-    parserTs
-  ] = await Promise.all([
+  const tsconfigPath = (options == null ? void 0 : options.tsconfigPath) ? toArray(options.tsconfigPath) : void 0;
+  const [pluginTs, parserTs] = await Promise.all([
     interopDefault(import("@typescript-eslint/eslint-plugin")),
     interopDefault(import("@typescript-eslint/parser"))
   ]);
@@ -1028,17 +981,21 @@ async function typescript(options = {}) {
           "@typescript-eslint/",
           "ts/"
         ),
-        "antfu/generic-spacing": "error",
-        "antfu/named-tuple-spacing": "error",
         "no-dupe-class-members": "off",
         "no-loss-of-precision": "off",
         "no-redeclare": "off",
         "no-use-before-define": "off",
         "no-useless-constructor": "off",
-        "ts/ban-ts-comment": ["error", { "ts-ignore": "allow-with-description" }],
+        "ts/ban-ts-comment": [
+          "error",
+          { "ts-ignore": "allow-with-description" }
+        ],
         "ts/ban-types": ["error", { types: { Function: false } }],
         "ts/consistent-type-definitions": ["error", "interface"],
-        "ts/consistent-type-imports": ["error", { disallowTypeAnnotations: false, prefer: "type-imports" }],
+        "ts/consistent-type-imports": [
+          "error",
+          { disallowTypeAnnotations: false, prefer: "type-imports" }
+        ],
         "ts/no-dupe-class-members": "error",
         "ts/no-dynamic-delete": "off",
         "ts/no-explicit-any": "off",
@@ -1050,11 +1007,21 @@ async function typescript(options = {}) {
         "ts/no-redeclare": "error",
         "ts/no-require-imports": "error",
         "ts/no-unused-vars": "off",
-        "ts/no-use-before-define": ["error", { classes: false, functions: false, variables: true }],
+        "ts/no-use-before-define": [
+          "error",
+          { classes: false, functions: false, variables: true }
+        ],
         "ts/no-useless-constructor": "off",
         "ts/prefer-ts-expect-error": "error",
         "ts/triple-slash-reference": "off",
         "ts/unified-signatures": "off",
+        ...overrides
+      }
+    },
+    {
+      files: filesTypeAware,
+      name: "coderwyd:typescript:rules-type-aware",
+      rules: {
         ...tsconfigPath ? typeAwareRules : {},
         ...overrides
       }
@@ -1096,6 +1063,7 @@ async function unicorn() {
         unicorn: import_eslint_plugin_unicorn.default
       },
       rules: {
+        "unicorn/better-regex": "error",
         // Pass error message when throwing errors
         "unicorn/error-message": "error",
         // Uppercase regex escapes
@@ -1129,35 +1097,20 @@ async function unicorn() {
 
 // src/configs/vue.ts
 async function vue(options = {}) {
-  const {
-    files = [GLOB_VUE],
-    overrides = {},
-    stylistic: stylistic2 = true
-  } = options;
-  const {
-    indent = 2
-  } = typeof stylistic2 === "boolean" ? {} : stylistic2;
+  const { files = [GLOB_VUE], overrides = {} } = options;
   const isVue3 = getVueVersion() === 3;
-  const [
-    pluginVue,
-    parserVue
-  ] = await Promise.all([
-    // @ts-expect-error missing types
+  const [pluginVue, parserVue] = await Promise.all([
     interopDefault(import("eslint-plugin-vue")),
     interopDefault(import("vue-eslint-parser"))
   ]);
-  const vue3Rules = {
-    ...pluginVue.configs.base.rules,
-    ...pluginVue.configs["vue3-essential"].rules,
-    ...pluginVue.configs["vue3-strongly-recommended"].rules,
-    ...pluginVue.configs["vue3-recommended"].rules
-  };
-  const vue2Rules = {
-    ...pluginVue.configs.base.rules,
-    ...pluginVue.configs.essential.rules,
-    ...pluginVue.configs["strongly-recommended"].rules,
-    ...pluginVue.configs.recommended.rules
-  };
+  const configKeys = isVue3 ? ["vue3-essential", "vue3-strongly-recommended", "vue3-recommended"] : ["essential", "strongly-recommended", "recommended"];
+  const vueRules = configKeys.reduce((preRules, key) => {
+    const config = pluginVue.configs[key];
+    return {
+      ...preRules,
+      ...config.rules
+    };
+  }, {});
   return [
     {
       name: "coderwyd:vue:setup",
@@ -1174,28 +1127,42 @@ async function vue(options = {}) {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: options.typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
+          parser: options.typescript ? await interopDefault(
+            import("@typescript-eslint/parser")
+          ) : null,
           sourceType: "module"
         }
       },
       name: "coderwyd:vue:rules",
       processor: pluginVue.processors[".vue"],
       rules: {
-        ...isVue3 ? vue3Rules : vue2Rules,
+        ...pluginVue.configs.base.rules,
+        ...vueRules,
         "node/prefer-global/process": "off",
-        "vue/block-order": ["error", {
-          order: ["script", "template", "style"]
-        }],
+        "vue/block-order": [
+          "error",
+          {
+            order: ["script", "template", "style"]
+          }
+        ],
         "vue/component-name-in-template-casing": ["error", "PascalCase"],
         "vue/component-options-name-casing": ["error", "PascalCase"],
         "vue/custom-event-name-casing": ["error", "camelCase"],
-        "vue/define-macros-order": ["error", {
-          order: ["defineOptions", "defineProps", "defineEmits", "defineSlots"]
-        }],
+        "vue/define-macros-order": [
+          "error",
+          {
+            order: [
+              "defineOptions",
+              "defineProps",
+              "defineEmits",
+              "defineSlots"
+            ]
+          }
+        ],
         "vue/dot-location": ["error", "property"],
         "vue/dot-notation": ["error", { allowKeywords: true }],
         "vue/eqeqeq": ["error", "smart"],
-        "vue/html-indent": ["error", indent],
+        "vue/html-indent": ["error", 2],
         "vue/html-quotes": ["error", "double"],
         "vue/max-attributes-per-line": "off",
         "vue/multi-word-component-names": "off",
@@ -1231,91 +1198,7 @@ async function vue(options = {}) {
         "vue/require-prop-types": "off",
         "vue/space-infix-ops": "error",
         "vue/space-unary-ops": ["error", { nonwords: false, words: true }],
-        ...stylistic2 ? {
-          "vue/array-bracket-spacing": ["error", "never"],
-          "vue/arrow-spacing": ["error", { after: true, before: true }],
-          "vue/block-spacing": ["error", "always"],
-          "vue/block-tag-newline": ["error", {
-            multiline: "always",
-            singleline: "always"
-          }],
-          "vue/brace-style": ["error", "stroustrup", { allowSingleLine: true }],
-          "vue/comma-dangle": ["error", "always-multiline"],
-          "vue/comma-spacing": ["error", { after: true, before: false }],
-          "vue/comma-style": ["error", "last"],
-          "vue/html-comment-content-spacing": ["error", "always", {
-            exceptions: ["-"]
-          }],
-          "vue/key-spacing": ["error", { afterColon: true, beforeColon: false }],
-          "vue/keyword-spacing": ["error", { after: true, before: true }],
-          "vue/object-curly-newline": "off",
-          "vue/object-curly-spacing": ["error", "always"],
-          "vue/object-property-newline": ["error", { allowMultiplePropertiesPerLine: true }],
-          "vue/operator-linebreak": ["error", "before"],
-          "vue/padding-line-between-blocks": ["error", "always"],
-          "vue/quote-props": ["error", "consistent-as-needed"],
-          "vue/space-in-parens": ["error", "never"],
-          "vue/template-curly-spacing": "error"
-        } : {},
-        ...overrides
-      }
-    }
-  ];
-}
-
-// src/configs/yaml.ts
-async function yaml(options = {}) {
-  const {
-    files = [GLOB_YAML],
-    overrides = {},
-    stylistic: stylistic2 = true
-  } = options;
-  const {
-    indent = 2,
-    quotes = "single"
-  } = typeof stylistic2 === "boolean" ? {} : stylistic2;
-  const [
-    pluginYaml,
-    parserYaml
-  ] = await Promise.all([
-    interopDefault(import("eslint-plugin-yml")),
-    interopDefault(import("yaml-eslint-parser"))
-  ]);
-  return [
-    {
-      name: "coderwyd:yaml:setup",
-      plugins: {
-        yaml: pluginYaml
-      }
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserYaml
-      },
-      name: "coderwyd:yaml:rules",
-      rules: {
-        "style/spaced-comment": "off",
-        "yaml/block-mapping": "error",
-        "yaml/block-sequence": "error",
-        "yaml/no-empty-key": "error",
-        "yaml/no-empty-sequence-entry": "error",
-        "yaml/no-irregular-whitespace": "error",
-        "yaml/plain-scalar": "error",
-        "yaml/vue-custom-block/no-parsing-error": "error",
-        ...stylistic2 ? {
-          "yaml/block-mapping-question-indicator-newline": "error",
-          "yaml/block-sequence-hyphen-indicator-newline": "error",
-          "yaml/flow-mapping-curly-newline": "error",
-          "yaml/flow-mapping-curly-spacing": "error",
-          "yaml/flow-sequence-bracket-newline": "error",
-          "yaml/flow-sequence-bracket-spacing": "error",
-          "yaml/indent": ["error", indent === "tab" ? 2 : indent],
-          "yaml/key-spacing": "error",
-          "yaml/no-tab-indent": "error",
-          "yaml/quotes": ["error", { avoidEscape: false, prefer: quotes }],
-          "yaml/spaced-comment": "error"
-        } : {},
+        "vue/valid-define-options": "warn",
         ...overrides
       }
     }
@@ -1324,15 +1207,8 @@ async function yaml(options = {}) {
 
 // src/configs/test.ts
 async function test(options = {}) {
-  const {
-    files = GLOB_TESTS,
-    isInEditor = false,
-    overrides = {}
-  } = options;
-  const [
-    pluginVitest,
-    pluginNoOnlyTests
-  ] = await Promise.all([
+  const { files = GLOB_TESTS, isInEditor = false, overrides = {} } = options;
+  const [pluginVitest, pluginNoOnlyTests] = await Promise.all([
     interopDefault(import("eslint-plugin-vitest")),
     // @ts-expect-error missing types
     interopDefault(import("eslint-plugin-no-only-tests"))
@@ -1356,8 +1232,12 @@ async function test(options = {}) {
       name: "coderwyd:test:rules",
       rules: {
         "node/prefer-global/process": "off",
-        "test/consistent-test-it": ["error", { fn: "it", withinDescribe: "it" }],
+        "test/consistent-test-it": [
+          "error",
+          { fn: "it", withinDescribe: "it" }
+        ],
         "test/no-identical-title": "error",
+        "test/no-import-node-test": "error",
         "test/no-only-tests": isInEditor ? "off" : "error",
         "test/prefer-hooks-in-order": "error",
         "test/prefer-lowercase-title": "error",
@@ -1381,9 +1261,7 @@ async function perfectionist() {
 
 // src/configs/react.ts
 var import_local_pkg2 = require("local-pkg");
-var ReactRefreshAllowConstantExportPackages = [
-  "vite"
-];
+var ReactRefreshAllowConstantExportPackages = ["vite"];
 async function react(options = {}) {
   const {
     files = [GLOB_JSX, GLOB_TSX],
@@ -1395,15 +1273,13 @@ async function react(options = {}) {
     "eslint-plugin-react-hooks",
     "eslint-plugin-react-refresh"
   ]);
-  const [
-    pluginReact,
-    pluginReactHooks,
-    pluginReactRefresh
-  ] = await Promise.all([
-    interopDefault(import("eslint-plugin-react")),
-    interopDefault(import("eslint-plugin-react-hooks")),
-    interopDefault(import("eslint-plugin-react-refresh"))
-  ]);
+  const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all(
+    [
+      interopDefault(import("eslint-plugin-react")),
+      interopDefault(import("eslint-plugin-react-hooks")),
+      interopDefault(import("eslint-plugin-react-refresh"))
+    ]
+  );
   const isAllowConstantExport = ReactRefreshAllowConstantExportPackages.some(
     (i) => (0, import_local_pkg2.isPackageExists)(i)
   );
@@ -1411,9 +1287,14 @@ async function react(options = {}) {
     {
       name: "coderwyd:react:setup",
       plugins: {
-        "react": pluginReact,
+        react: pluginReact,
         "react-hooks": pluginReactHooks,
         "react-refresh": pluginReactRefresh
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
       }
     },
     {
@@ -1471,21 +1352,14 @@ async function react(options = {}) {
 
 // src/configs/unocss.ts
 async function unocss(options = {}) {
-  const {
-    attributify = true,
-    strict = false
-  } = options;
-  await ensurePackages([
-    "@unocss/eslint-plugin"
-  ]);
-  const [
-    pluginUnoCSS
-  ] = await Promise.all([
+  const { attributify = true, strict = false } = options;
+  await ensurePackages(["@unocss/eslint-plugin"]);
+  const [pluginUnoCSS] = await Promise.all([
     interopDefault(import("@unocss/eslint-plugin"))
   ]);
   return [
     {
-      name: "antfu:unocss",
+      name: "coderwyd:unocss",
       plugins: {
         unocss: pluginUnoCSS
       },
@@ -1502,7 +1376,82 @@ async function unocss(options = {}) {
   ];
 }
 
-// src/factory.ts
+// src/configs/formatter.ts
+async function formatter(options = {}, prettierRules2 = {}) {
+  await ensurePackages(["eslint-plugin-prettier"]);
+  const {
+    css = true,
+    graphql,
+    html = true,
+    markdown,
+    toml,
+    yaml
+  } = options || {};
+  const pluginPrettier = await interopDefault(import("eslint-plugin-prettier"));
+  function createPrettierFormatter(files, parser, plugins) {
+    const rules = {
+      ...prettierRules2,
+      parser
+    };
+    if (plugins == null ? void 0 : plugins.length) {
+      rules.plugins = [...rules.plugins || [], ...plugins];
+    }
+    const config = {
+      files,
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: `coderwyd:formatter:${parser}`,
+      plugins: {
+        prettier: pluginPrettier
+      },
+      rules: {
+        "prettier/prettier": ["warn", rules]
+      }
+    };
+    return config;
+  }
+  const configs = [
+    {
+      name: "coderwyd:formatter:setup",
+      plugins: {
+        prettier: pluginPrettier
+      }
+    }
+  ];
+  if (css) {
+    const cssConfig = createPrettierFormatter([GLOB_CSS, GLOB_POSTCSS], "css");
+    const scssConfig = createPrettierFormatter([GLOB_SCSS], "scss");
+    const lessConfig = createPrettierFormatter([GLOB_LESS], "less");
+    configs.push(cssConfig, scssConfig, lessConfig);
+  }
+  if (html) {
+    const htmlConfig = createPrettierFormatter([GLOB_HTML], "html");
+    configs.push(htmlConfig);
+  }
+  if (markdown) {
+    const markdownConfig = createPrettierFormatter([GLOB_MARKDOWN], "markdown");
+    configs.push(markdownConfig);
+  }
+  if (graphql) {
+    const graphqlConfig = createPrettierFormatter([GLOB_GRAPHQL], "graphql");
+    configs.push(graphqlConfig);
+  }
+  if (yaml) {
+    const yamlConfig = createPrettierFormatter([GLOB_YAML], "yaml");
+    configs.push(yamlConfig);
+  }
+  if (toml) {
+    await ensurePackages(["@toml-tools/parser", "prettier-plugin-toml"]);
+    const tomlConfig = createPrettierFormatter([GLOB_TOML], "toml", [
+      "prettier-plugin-toml"
+    ]);
+    configs.push(tomlConfig);
+  }
+  return configs;
+}
+
+// src/index.ts
 var flatConfigProps = [
   "files",
   "ignores",
@@ -1513,49 +1462,45 @@ var flatConfigProps = [
   "rules",
   "settings"
 ];
-var VuePackages = [
-  "vue",
-  "nuxt",
-  "vitepress",
-  "@slidev/cli"
-];
-async function coderwyd(options = {}, ...userConfigs) {
+var VuePackages = ["vue", "nuxt", "vitepress", "@slidev/cli"];
+async function defineConfig(options = {}, ...userConfigs) {
   const {
     componentExts = [],
     gitignore: enableGitignore = true,
-    isInEditor = !!((import_node_process3.default.env.VSCODE_PID || import_node_process3.default.env.JETBRAINS_IDE) && !import_node_process3.default.env.CI),
-    overrides = {},
+    isInEditor = !!((import_node_process3.default.env.VSCODE_PID || import_node_process3.default.env.JETBRAINS_IDE || import_node_process3.default.env.VIM) && !import_node_process3.default.env.CI),
     react: enableReact = false,
     typescript: enableTypeScript = (0, import_local_pkg3.isPackageExists)("typescript"),
     unocss: enableUnoCSS = false,
+    usePrettierrc = true,
     vue: enableVue = VuePackages.some((i) => (0, import_local_pkg3.isPackageExists)(i))
   } = options;
-  const stylisticOptions = options.stylistic === false ? false : typeof options.stylistic === "object" ? options.stylistic : {};
-  if (stylisticOptions && !("jsx" in stylisticOptions))
-    stylisticOptions.jsx = options.jsx ?? true;
   const configs = [];
   if (enableGitignore) {
     if (typeof enableGitignore !== "boolean") {
-      configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r(enableGitignore)]));
+      configs.push(
+        interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+          r(enableGitignore)
+        ])
+      );
     } else {
       if (import_node_fs.default.existsSync(".gitignore"))
-        configs.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [r()]));
+        configs.push(
+          interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+            r()
+          ])
+        );
     }
   }
   configs.push(
     ignores(),
     javascript({
       isInEditor,
-      overrides: overrides.javascript
+      overrides: getOverrides(options, "javascript")
     }),
     comments(),
     node(),
-    jsdoc({
-      stylistic: stylisticOptions
-    }),
-    imports({
-      stylistic: stylisticOptions
-    }),
+    jsdoc(),
+    imports(),
     unicorn(),
     // Optional plugins (installed but not enabled by default)
     perfectionist()
@@ -1563,60 +1508,70 @@ async function coderwyd(options = {}, ...userConfigs) {
   if (enableVue)
     componentExts.push("vue");
   if (enableTypeScript) {
-    configs.push(typescript({
-      ...typeof enableTypeScript !== "boolean" ? enableTypeScript : {},
-      componentExts,
-      overrides: overrides.typescript
-    }));
+    configs.push(
+      typescript({
+        ...resolveSubOptions(options, "typescript"),
+        componentExts
+      })
+    );
   }
-  if (stylisticOptions)
-    configs.push(stylistic(stylisticOptions));
   if (options.test ?? true) {
-    configs.push(test({
-      isInEditor,
-      overrides: overrides.test
-    }));
+    configs.push(
+      test({
+        isInEditor,
+        overrides: getOverrides(options, "test")
+      })
+    );
   }
   if (enableVue) {
-    configs.push(vue({
-      overrides: overrides.vue,
-      stylistic: stylisticOptions,
-      typescript: !!enableTypeScript
-    }));
+    configs.push(
+      vue({
+        ...resolveSubOptions(options, "vue"),
+        typescript: !!enableTypeScript
+      })
+    );
   }
   if (enableReact) {
-    configs.push(react({
-      overrides: overrides.react,
-      typescript: !!enableTypeScript
-    }));
+    configs.push(
+      react({
+        overrides: getOverrides(options, "react"),
+        typescript: !!enableTypeScript
+      })
+    );
   }
   if (enableUnoCSS) {
-    configs.push(unocss(
-      typeof enableUnoCSS === "boolean" ? {} : enableUnoCSS
-    ));
+    configs.push(
+      unocss({
+        ...resolveSubOptions(options, "unocss"),
+        overrides: getOverrides(options, "unocss")
+      })
+    );
   }
   if (options.jsonc ?? true) {
     configs.push(
       jsonc({
-        overrides: overrides.jsonc,
-        stylistic: stylisticOptions
+        overrides: getOverrides(options, "jsonc")
       }),
       sortPackageJson(),
       sortTsconfig()
     );
   }
-  if (options.yaml ?? true) {
-    configs.push(yaml({
-      overrides: overrides.yaml,
-      stylistic: stylisticOptions
-    }));
+  let prettierRules2 = {
+    ...DEFAULT_PRETTIER_RULES
+  };
+  if (options.prettierRules) {
+    prettierRules2 = { ...prettierRules2, ...options.prettierRules };
   }
-  if (options.markdown ?? true) {
-    configs.push(markdown({
-      componentExts,
-      overrides: overrides.markdown
-    }));
+  if (usePrettierrc) {
+    const prettierConfig = await loadPrettierConfig(
+      options.cwd ?? import_node_process3.default.cwd()
+    );
+    Object.assign(prettierRules2, prettierConfig);
   }
+  configs.push(
+    prettier(prettierRules2),
+    formatter(options.formatter, prettierRules2)
+  );
   const fusedConfig = flatConfigProps.reduce((acc, key) => {
     if (key in options)
       acc[key] = options[key];
@@ -1624,62 +1579,10 @@ async function coderwyd(options = {}, ...userConfigs) {
   }, {});
   if (Object.keys(fusedConfig).length)
     configs.push([fusedConfig]);
-  const merged = combine(
-    ...configs,
-    ...userConfigs
-  );
+  const merged = combine(...configs, ...userConfigs);
   return merged;
 }
-
-// src/index.ts
-var src_default = coderwyd;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GLOB_ALL_SRC,
-  GLOB_CSS,
-  GLOB_EXCLUDE,
-  GLOB_HTML,
-  GLOB_JS,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_JSONC,
-  GLOB_JSX,
-  GLOB_LESS,
-  GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE,
-  GLOB_SCSS,
-  GLOB_SRC,
-  GLOB_SRC_EXT,
-  GLOB_STYLE,
-  GLOB_TESTS,
-  GLOB_TS,
-  GLOB_TSX,
-  GLOB_VUE,
-  GLOB_YAML,
-  coderwyd,
-  combine,
-  comments,
-  ensurePackages,
-  getVueVersion,
-  ignores,
-  imports,
-  interopDefault,
-  javascript,
-  jsdoc,
-  jsonc,
-  markdown,
-  node,
-  perfectionist,
-  react,
-  renameRules,
-  sortPackageJson,
-  sortTsconfig,
-  stylistic,
-  test,
-  toArray,
-  typescript,
-  unicorn,
-  unocss,
-  vue,
-  yaml
+  defineConfig
 });