@vinicunca/eslint-config 2.0.12 → 2.1.0

package/dist/index.js

@@ -15,9 +15,6 @@ function purry(fn, args, lazy) {
   }
   throw new Error("Wrong number of arguments");
 }
-function isArray(data) {
-  return Array.isArray(data);
-}
 function isBoolean(data) {
   return typeof data === "boolean";
 }
@@ -36,21 +33,6 @@ function toString(value) {
 function isObject(data) {
   return toString(data) === "[object Object]";
 }
-function isString(data) {
-  return typeof data === "string";
-}
-function isEmpty(data) {
-  if (isArray(data) || isString(data)) {
-    return data.length === 0;
-  }
-  if (isObject(data)) {
-    for (const _ in data) {
-      return false;
-    }
-    return !(data instanceof RegExp);
-  }
-  return false;
-}
 function _countBy(indexed) {
   return (array, fn) => {
     return array.reduce((ret, item, index) => {
@@ -977,7 +959,7 @@ function toPairs(object) {
 
 // src/base.ts
 import { isPackageExists } from "local-pkg";
-import process3 from "process";
+import process2 from "process";
 
 // src/flags.ts
 var ERROR = "error";
@@ -1019,16 +1001,50 @@ import fs from "fs";
 import parseGitignore from "parse-gitignore";
 
 // src/globs.ts
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_SRC_EXT = "?([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_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_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
+var GLOB_VUE = "**/*.vue";
+var GLOB_YAML = "**/*.y?(a)ml";
+var GLOB_HTML = "**/*.htm?(l)";
+var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
+var GLOB_TESTS = [
+  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
+  `**/*.spec.${GLOB_SRC_EXT}`,
+  `**/*.test.${GLOB_SRC_EXT}`,
+  `**/*.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",
   "**/package-lock.json",
   "**/yarn.lock",
   "**/pnpm-lock.yaml",
+  "**/bun.lockb",
   "**/output",
   "**/coverage",
   "**/temp",
@@ -1052,23 +1068,6 @@ var GLOB_EXCLUDE = [
   "**/auto-import?(s).d.ts",
   "**/components.d.ts"
 ];
-var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
-var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
-var GLOB_TESTS = [
-  `**/__tests__/**/*.${GLOB_SRC_EXT}`,
-  `**/*.spec.${GLOB_SRC_EXT}`,
-  `**/*.test.${GLOB_SRC_EXT}`,
-  `**/*.bench.${GLOB_SRC_EXT}`,
-  `**/*.benchmark.${GLOB_SRC_EXT}`
-];
-var GLOB_VUE = "**/*.vue";
-var GLOB_JSON = "**/*.json";
-var GLOB_JSON5 = "**/*.json5";
-var GLOB_JSONC = "**/*.jsonc";
-var GLOB_YAML = "**/*.y?(a)ml";
-var GLOB_MARKDOWN = "**/*.md";
-var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
-var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
 
 // src/configs/ignores.ts
 async function ignores({
@@ -1144,6 +1143,7 @@ async function javascript(options = {}) {
       languageOptions: {
         ecmaVersion: 2022,
         globals: {
+          ...globals.browser,
           ...globals.es2021,
           ...globals.node,
           document: "readonly",
@@ -1426,8 +1426,8 @@ async function javascript(options = {}) {
 
 // src/utils.ts
 async function combineConfigs(...configs) {
-  const resolvedConfigs = await Promise.all(configs);
-  return resolvedConfigs.flatMap((config) => Array.isArray(config) ? config : [config]);
+  const resolved = await Promise.all(configs);
+  return resolved.flat();
 }
 function renameRules(rules, from, to) {
   return Object.fromEntries(
@@ -1444,9 +1444,35 @@ async function interopDefault(m) {
   const resolved = await m;
   return resolved.default || resolved;
 }
+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: []
+    }
+  })
+};
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
 
 // src/configs/jsdoc.ts
-async function jsdoc() {
+async function jsdoc(options = {}) {
+  const {
+    stylistic: stylistic2 = true
+  } = options;
   return [
     {
       name: "vinicunca:jsdoc",
@@ -1473,7 +1499,11 @@ async function jsdoc() {
         "jsdoc/require-returns-check": WARN,
         "jsdoc/require-returns-description": WARN,
         "jsdoc/require-yields-check": WARN,
-        "jsdoc/valid-types": WARN
+        "jsdoc/valid-types": WARN,
+        ...stylistic2 ? {
+          "jsdoc/check-alignment": "warn",
+          "jsdoc/multiline-blocks": "warn"
+        } : {}
       }
     }
   ];
@@ -1555,30 +1585,41 @@ async function jsonc(options = {}) {
 }
 
 // src/configs/markdown.ts
+import { mergeProcessors, processorPassThrough } from "eslint-merge-processors";
 async function markdown(options = {}) {
   const {
     componentExts = [],
     files = [GLOB_MARKDOWN],
     overrides = {}
   } = options;
+  const markdown2 = await interopDefault(import("eslint-plugin-markdown"));
   return [
     {
       name: "vinicunca:markdown:setup",
       plugins: {
-        // @ts-expect-error missing types
-        markdown: await interopDefault(import("eslint-plugin-markdown"))
+        markdown: markdown2
       }
     },
     {
       files,
       ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
       name: "vinicunca:markdown:processor",
-      processor: "markdown/markdown"
+      /**
+       * `eslint-plugin-markdown` only creates virtual files for code blocks,
+       * but not the markdown file itself. We use `eslint-merge-processors` to
+       * add a pass-through processor for the markdown file itself.
+       */
+      processor: mergeProcessors([
+        markdown2.processors.markdown,
+        processorPassThrough
+      ])
     },
     {
-      files: [GLOB_MARKDOWN],
-      name: "vinicunca:markdown:processor",
-      processor: "markdown/markdown"
+      files,
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:markdown:parser"
     },
     {
       files: [
@@ -1632,7 +1673,6 @@ async function markdown(options = {}) {
           "ts/restrict-template-expressions": OFF,
           "ts/unbound-method": OFF
         },
-        "vinicunca/no-cjs-exports": OFF,
         "vinicunca/no-ts-export-equal": OFF,
         ...overrides
       }
@@ -2001,6 +2041,8 @@ var STYLISTIC_CONFIG_DEFAULTS = {
 async function stylistic(options = {}) {
   const {
     indent,
+    jsx,
+    overrides = {},
     quotes,
     semi
   } = {
@@ -2008,6 +2050,14 @@ async function stylistic(options = {}) {
     ...options
   };
   const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
+  const config = pluginStylistic.configs.customize({
+    flat: true,
+    indent,
+    jsx,
+    pluginName: "style",
+    quotes,
+    semi
+  });
   return [
     {
       name: "vinicunca:stylistic",
@@ -2016,83 +2066,15 @@ async function stylistic(options = {}) {
         vinicunca: default2
       },
       rules: {
+        ...config.rules,
         "curly": [ERROR, "all"],
         "style/array-bracket-newline": [ERROR, CONSISTENT],
         "style/array-bracket-spacing": [ERROR, NEVER],
         "style/array-element-newline": [ERROR, CONSISTENT],
         "style/arrow-parens": [ERROR, ALWAYS],
-        "style/arrow-spacing": [ERROR, { after: true, before: true }],
-        "style/block-spacing": [ERROR, ALWAYS],
         "style/brace-style": [ERROR],
-        "style/comma-dangle": [ERROR, "always-multiline"],
-        "style/comma-spacing": [ERROR, { after: true, before: false }],
-        "style/comma-style": [ERROR, "last"],
-        "style/computed-property-spacing": [ERROR, NEVER, { enforceForClassMembers: true }],
-        "style/dot-location": [ERROR, "property"],
-        "style/eol-last": ERROR,
         "style/func-call-spacing": [ERROR, NEVER],
-        "style/indent": [ERROR, indent, {
-          ArrayExpression: 1,
-          CallExpression: { arguments: 1 },
-          FunctionDeclaration: { body: 1, parameters: 1 },
-          FunctionExpression: { body: 1, parameters: 1 },
-          ImportDeclaration: 1,
-          MemberExpression: 1,
-          ObjectExpression: 1,
-          SwitchCase: 1,
-          VariableDeclarator: 1,
-          flatTernaryExpressions: false,
-          ignoreComments: false,
-          ignoredNodes: [
-            "TemplateLiteral *",
-            "JSXElement",
-            "JSXElement > *",
-            "JSXAttribute",
-            "JSXIdentifier",
-            "JSXNamespacedName",
-            "JSXMemberExpression",
-            "JSXSpreadAttribute",
-            "JSXExpressionContainer",
-            "JSXOpeningElement",
-            "JSXClosingElement",
-            "JSXFragment",
-            "JSXOpeningFragment",
-            "JSXClosingFragment",
-            "JSXText",
-            "JSXEmptyExpression",
-            "JSXSpreadChild",
-            "TSTypeParameterInstantiation",
-            "FunctionExpression > .params[decorators.length > 0]",
-            "FunctionExpression > .params > :matches(Decorator, :not(:first-child))",
-            "ClassBody.body > PropertyDefinition[decorators.length > 0] > .key"
-          ],
-          offsetTernaryExpressions: true,
-          outerIIFEBody: 1
-        }],
-        "style/indent-binary-ops": [ERROR, indent],
-        "style/key-spacing": [ERROR, { afterColon: true, beforeColon: false }],
-        "style/keyword-spacing": [ERROR, { after: true, before: true }],
-        "style/lines-between-class-members": [ERROR, ALWAYS, { exceptAfterSingleLine: true }],
-        "style/max-statements-per-line": [ERROR, { max: 1 }],
         "style/member-delimiter-style": [ERROR],
-        "style/multiline-ternary": [ERROR, "always-multiline"],
-        "style/new-parens": ERROR,
-        "style/no-extra-parens": [ERROR, "functions"],
-        "style/no-floating-decimal": ERROR,
-        "style/no-mixed-operators": [ERROR, {
-          allowSamePrecedence: true,
-          groups: [
-            ["==", "!=", "===", "!==", ">", ">=", "<", "<="],
-            ["&&", "||"],
-            ["in", "instanceof"]
-          ]
-        }],
-        "style/no-mixed-spaces-and-tabs": ERROR,
-        "style/no-multi-spaces": ERROR,
-        "style/no-multiple-empty-lines": [ERROR, { max: 1, maxBOF: 0, maxEOF: 1 }],
-        "style/no-tabs": ERROR,
-        "style/no-trailing-spaces": ERROR,
-        "style/no-whitespace-before-property": ERROR,
         "style/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
         "style/object-curly-spacing": [ERROR, ALWAYS],
         "style/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
@@ -2103,36 +2085,10 @@ async function stylistic(options = {}) {
         "style/rest-spread-spacing": [ERROR, NEVER],
         "style/semi": [ERROR, semi ? ALWAYS : NEVER],
         "style/semi-spacing": [ERROR, { after: true, before: false }],
-        "style/space-before-blocks": [ERROR, ALWAYS],
-        "style/space-before-function-paren": [ERROR, {
-          anonymous: NEVER,
-          asyncArrow: ALWAYS,
-          named: NEVER
-        }],
-        "style/space-in-parens": [ERROR, NEVER],
-        "style/space-infix-ops": ERROR,
-        "style/space-unary-ops": [ERROR, { nonwords: false, words: true }],
-        "style/spaced-comment": [ERROR, "always", {
-          block: {
-            balanced: true,
-            exceptions: ["*"],
-            markers: ["!"]
-          },
-          line: {
-            exceptions: ["/", "#"],
-            markers: ["/"]
-          }
-        }],
-        "style/template-curly-spacing": ERROR,
-        "style/template-tag-spacing": [ERROR, NEVER],
-        "style/type-annotation-spacing": [ERROR, {}],
-        "style/wrap-iife": [ERROR, "any", {
-          functionPrototypeMethods: true
-        }],
-        "style/yield-star-spacing": [ERROR, "both"],
         "vinicunca/consistent-list-newline": ERROR,
         "vinicunca/if-newline": ERROR,
-        "vinicunca/top-level-function": ERROR
+        "vinicunca/top-level-function": ERROR,
+        ...overrides
       }
     },
     {
@@ -2177,6 +2133,7 @@ async function test(options = {}) {
       files,
       name: "vinicunca:test:rules",
       rules: {
+        "node/prefer-global/process": OFF,
         "test/consistent-test-it": [ERROR, { fn: "it", withinDescribe: "it" }],
         "test/no-identical-title": ERROR,
         "test/no-only-tests": isInEditor ? OFF : ERROR,
@@ -2194,13 +2151,13 @@ async function typescript(options = {}) {
   const {
     componentExts = [],
     overrides = {},
-    parserOptions = {},
-    tsconfigPath = []
+    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,
@@ -2216,31 +2173,19 @@ async function typescript(options = {}) {
     "ts/restrict-plus-operands": ERROR,
     "ts/restrict-template-expressions": ERROR
   };
-  let tsConfigOptions = {};
-  let additionalTypeAwareRules = {};
-  if (!isEmpty(tsconfigPath)) {
-    tsConfigOptions = {
-      project: tsconfigPath,
-      tsconfigRootDir: process.cwd()
-    };
-    additionalTypeAwareRules = typeAwareRules;
-  }
+  const tsconfigPath = options?.tsconfigPath ? toArray(options.tsconfigPath) : void 0;
   const [
     pluginTs,
-    parserTs,
-    pluginStylistic
+    parserTs
   ] = await Promise.all([
     interopDefault(import("@typescript-eslint/eslint-plugin")),
-    interopDefault(import("@typescript-eslint/parser")),
-    interopDefault(import("@stylistic/eslint-plugin"))
+    interopDefault(import("@typescript-eslint/parser"))
   ]);
   return [
     {
       // Install the plugins without globs, so they can be configured separately.
       name: "vinicunca:typescript:setup",
       plugins: {
-        import: pluginImport,
-        style: pluginStylistic,
         ts: pluginTs,
         vinicunca: default2
       }
@@ -2252,7 +2197,10 @@ async function typescript(options = {}) {
         parserOptions: {
           extraFileExtensions: componentExts.map((ext) => `.${ext}`),
           sourceType: "module",
-          ...tsConfigOptions,
+          ...tsconfigPath ? {
+            project: tsconfigPath,
+            tsconfigRootDir: process.cwd()
+          } : {},
           ...parserOptions
         }
       },
@@ -2275,8 +2223,6 @@ async function typescript(options = {}) {
         "no-unused-vars": OFF,
         "no-use-before-define": OFF,
         "no-useless-constructor": OFF,
-        "style/type-generic-spacing": ERROR,
-        "style/type-named-tuple-spacing": ERROR,
         "ts/ban-ts-comment": [ERROR, { "ts-ignore": "allow-with-description" }],
         "ts/ban-types": [ERROR, { types: { Function: false } }],
         "ts/consistent-type-definitions": [ERROR, "interface"],
@@ -2305,9 +2251,14 @@ async function typescript(options = {}) {
         "ts/parameter-properties": OFF,
         "ts/prefer-ts-expect-error": ERROR,
         "ts/triple-slash-reference": OFF,
-        "vinicunca/no-cjs-exports": ERROR,
-        "vinicunca/no-ts-export-equal": ERROR,
-        ...additionalTypeAwareRules,
+        ...overrides
+      }
+    },
+    {
+      files: filesTypeAware,
+      name: "vinicunca:typescript:rules-type-aware",
+      rules: {
+        ...tsconfigPath ? typeAwareRules : {},
         ...overrides
       }
     },
@@ -2317,6 +2268,7 @@ async function typescript(options = {}) {
       rules: {
         "eslint-comments/no-unlimited-disable": OFF,
         "import/no-duplicates": OFF,
+        "no-restricted-syntax": "off",
         "unused-imports/no-unused-vars": OFF
       }
     },
@@ -2339,10 +2291,7 @@ async function typescript(options = {}) {
 }
 
 // src/configs/unicorn.ts
-async function unicorn(options = {}) {
-  const {
-    overrides = {}
-  } = options;
+async function unicorn() {
   return [
     {
       name: "vinicunca:unicorn",
@@ -2362,8 +2311,7 @@ async function unicorn(options = {}) {
         "unicorn/prefer-number-properties": ERROR,
         "unicorn/prefer-string-starts-ends-with": ERROR,
         "unicorn/prefer-type-error": ERROR,
-        "unicorn/throw-new-error": ERROR,
-        ...overrides
+        "unicorn/throw-new-error": ERROR
       }
     }
   ];
@@ -2400,32 +2348,26 @@ async function unocss(options = {}) {
 }
 
 // src/configs/vue.ts
-import process2 from "process";
+import { mergeProcessors as mergeProcessors2 } from "eslint-merge-processors";
 async function vue(options = {}) {
   const {
     files = [GLOB_VUE],
     overrides = {},
-    stylistic: stylistic2 = true,
-    typescript: typescript2 = {}
+    stylistic: stylistic2 = true
   } = options;
+  const sfcBlocks = options.sfcBlocks === true ? {} : options.sfcBlocks ?? {};
   const {
     indent = 2
   } = isBoolean(stylistic2) ? {} : stylistic2;
-  let tsConfigOptions = {};
-  const tsconfigPath = typescript2.tsconfigPath ?? [];
-  if (!isEmpty(tsconfigPath)) {
-    tsConfigOptions = {
-      project: tsconfigPath,
-      tsconfigRootDir: process2.cwd()
-    };
-  }
   const [
     pluginVue,
-    parserVue
+    parserVue,
+    processorVueBlocks
   ] = await Promise.all([
     // @ts-expect-error missing types
     interopDefault(import("eslint-plugin-vue")),
-    interopDefault(import("vue-eslint-parser"))
+    interopDefault(import("vue-eslint-parser")),
+    interopDefault(import("eslint-processor-vue-blocks"))
   ]);
   return [
     {
@@ -2443,39 +2385,30 @@ async function vue(options = {}) {
             jsx: true
           },
           extraFileExtensions: [".vue"],
-          parser: typescript2.enabled ? await interopDefault(import("@typescript-eslint/parser")) : null,
-          sourceType: "module",
-          ...tsConfigOptions
+          parser: options.typescript ? await interopDefault(import("@typescript-eslint/parser")) : null,
+          sourceType: "module"
         }
       },
       name: "vinicunca:vue:rules",
-      processor: pluginVue.processors[".vue"],
+      processor: sfcBlocks === false ? pluginVue.processors[".vue"] : mergeProcessors2([
+        pluginVue.processors[".vue"],
+        processorVueBlocks({
+          ...sfcBlocks,
+          blocks: {
+            styles: true,
+            ...sfcBlocks.blocks
+          }
+        })
+      ]),
       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/array-bracket-spacing": [ERROR, NEVER],
-        "vue/arrow-spacing": [ERROR, {
-          after: true,
-          before: true
-        }],
         "vue/block-order": [ERROR, {
           order: ["script", "template", "style"]
         }],
-        "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/component-name-in-template-casing": [ERROR, "PascalCase"],
         "vue/component-options-name-casing": [ERROR, "PascalCase"],
         "vue/custom-event-name-casing": [ERROR, "camelCase"],
@@ -2485,18 +2418,7 @@ async function vue(options = {}) {
         "vue/dot-location": [ERROR, "property"],
         "vue/dot-notation": [ERROR, { allowKeywords: true }],
         "vue/eqeqeq": [ERROR, "smart"],
-        "vue/html-comment-content-spacing": [ERROR, ALWAYS, {
-          exceptions: ["-"]
-        }],
         "vue/html-indent": [ERROR, indent],
-        "vue/key-spacing": [ERROR, {
-          afterColon: true,
-          beforeColon: false
-        }],
-        "vue/keyword-spacing": [ERROR, {
-          after: true,
-          before: true
-        }],
         "vue/max-attributes-per-line": [ERROR],
         "vue/multi-word-component-names": OFF,
         "vue/no-constant-condition": WARN,
@@ -2519,28 +2441,58 @@ async function vue(options = {}) {
         "vue/no-useless-v-bind": ERROR,
         "vue/no-v-html": OFF,
         "vue/no-v-text-v-html-on-component": OFF,
-        "vue/object-curly-newline": [ERROR, { consistent: true, multiline: true }],
-        "vue/object-curly-spacing": [ERROR, ALWAYS],
-        "vue/object-property-newline": [ERROR, { allowMultiplePropertiesPerLine: true }],
         "vue/object-shorthand": [ERROR, ALWAYS, {
           avoidQuotes: true,
           ignoreConstructors: false
         }],
-        "vue/operator-linebreak": [ERROR, "before"],
-        "vue/padding-line-between-blocks": [ERROR, ALWAYS],
         "vue/prefer-import-from-vue": OFF,
         "vue/prefer-separate-static-class": ERROR,
         "vue/prefer-template": ERROR,
-        "vue/quote-props": [ERROR, "consistent-as-needed"],
         "vue/require-default-prop": OFF,
         "vue/require-prop-types": OFF,
-        "vue/space-in-parens": [ERROR, NEVER],
         "vue/space-infix-ops": ERROR,
         "vue/space-unary-ops": [ERROR, {
           nonwords: false,
           words: true
         }],
-        "vue/template-curly-spacing": ERROR,
+        ...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": [ERROR, { consistent: true, multiline: true }],
+          "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
       }
     }
@@ -2581,51 +2533,219 @@ async function yaml(options = {}) {
       rules: {
         "style/spaced-comment": OFF,
         "yaml/block-mapping": ERROR,
-        "yaml/block-mapping-question-indicator-newline": ERROR,
         "yaml/block-sequence": 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-empty-key": ERROR,
         "yaml/no-empty-sequence-entry": ERROR,
         "yaml/no-irregular-whitespace": ERROR,
-        "yaml/no-tab-indent": ERROR,
         "yaml/plain-scalar": ERROR,
-        "yaml/quotes": [ERROR, { avoidEscape: false, prefer: quotes }],
-        "yaml/spaced-comment": 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
+        } : {},
         ...overrides
       }
     }
   ];
 }
 
+// src/configs/formatters.ts
+async function formatters(options = {}, stylistic2 = {}) {
+  if (options === true) {
+    options = {
+      css: true,
+      graphql: true,
+      html: true,
+      markdown: true
+    };
+  }
+  const {
+    indent,
+    quotes,
+    semi
+  } = {
+    ...STYLISTIC_CONFIG_DEFAULTS,
+    ...stylistic2
+  };
+  const prettierOptions = Object.assign(
+    {
+      endOfLine: "auto",
+      semi,
+      singleQuote: quotes === "single",
+      tabWidth: typeof indent === "number" ? indent : 2,
+      trailingComma: "all",
+      useTabs: indent === "tab"
+    },
+    options.prettierOptions || {}
+  );
+  const dprintOptions = Object.assign(
+    {
+      indentWidth: typeof indent === "number" ? indent : 2,
+      quoteStyle: quotes === "single" ? "preferSingle" : "preferDouble",
+      useTabs: indent === "tab"
+    },
+    options.dprintOptions || {}
+  );
+  const pluginFormat = await interopDefault(import("eslint-plugin-format"));
+  const configs = [
+    {
+      name: "vinicunca:formatters:setup",
+      plugins: {
+        format: pluginFormat
+      }
+    }
+  ];
+  if (options.css) {
+    configs.push(
+      {
+        files: [GLOB_CSS, GLOB_POSTCSS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatter:css",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "css"
+            }
+          ]
+        }
+      },
+      {
+        files: [GLOB_SCSS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatter:scss",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "scss"
+            }
+          ]
+        }
+      },
+      {
+        files: [GLOB_LESS],
+        languageOptions: {
+          parser: parserPlain
+        },
+        name: "vinicunca:formatter:less",
+        rules: {
+          "format/prettier": [
+            "error",
+            {
+              ...prettierOptions,
+              parser: "less"
+            }
+          ]
+        }
+      }
+    );
+  }
+  if (options.html) {
+    configs.push({
+      files: ["**/*.html"],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:formatter:html",
+      rules: {
+        "format/prettier": [
+          "error",
+          {
+            ...prettierOptions,
+            parser: "html"
+          }
+        ]
+      }
+    });
+  }
+  if (options.markdown) {
+    const formater = options.markdown === true ? "prettier" : options.markdown;
+    configs.push({
+      files: [GLOB_MARKDOWN],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:formatter:markdown",
+      rules: {
+        [`format/${formater}`]: [
+          "error",
+          formater === "prettier" ? {
+            printWidth: 120,
+            ...prettierOptions,
+            embeddedLanguageFormatting: "off",
+            parser: "markdown"
+          } : {
+            ...dprintOptions,
+            language: "markdown"
+          }
+        ]
+      }
+    });
+  }
+  if (options.graphql) {
+    configs.push({
+      files: ["**/*.graphql"],
+      languageOptions: {
+        parser: parserPlain
+      },
+      name: "vinicunca:formatter:graphql",
+      rules: {
+        "format/prettier": [
+          "error",
+          {
+            ...prettierOptions,
+            parser: "graphql"
+          }
+        ]
+      }
+    });
+  }
+  return configs;
+}
+
 // src/base.ts
+var flatConfigProps = [
+  "files",
+  "ignores",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
 var VuePackages = [
   "vue",
   "nuxt",
   "vitepress",
   "@slidev/cli"
 ];
-async function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
+async function vinicuncaESLint(options = {}, ...userConfigs) {
   const {
     componentExts = [],
-    isInEditor = !!((process3.env.VSCODE_PID || process3.env.JETBRAINS_IDE) && !process3.env.CI),
-    jsonc: enableJsonc = true,
-    markdown: enableMarkdown = true,
-    overrides = {},
+    isInEditor = !!((process2.env.VSCODE_PID || process2.env.JETBRAINS_IDE || process2.env.VIM) && !process2.env.CI),
     react: enableReact = false,
-    test: enableTest = true,
-    typescript: tsOptions = {},
+    typescript: enableTypeScript = isPackageExists("typescript"),
     unocss: enableUnoCSS = false,
-    vue: enableVue = VuePackages.some((i) => isPackageExists(i)),
-    yaml: enableYaml = true
+    vue: enableVue = VuePackages.some((i) => isPackageExists(i))
   } = options;
-  let stylisticOptions = true;
+  let stylisticOptions = {};
   if (options.stylistic === false) {
     stylisticOptions = false;
   } else if (isObject(options.stylistic)) {
@@ -2639,105 +2759,138 @@ async function vinicuncaESLint({ options = {}, userConfigs = [] } = {}) {
     ignores(options.ignores),
     javascript({
       isInEditor,
-      overrides: overrides.javascript
+      overrides: getOverrides(options, "javascript")
     }),
     comments(),
     node(),
-    jsdoc(),
+    jsdoc({
+      stylistic: stylisticOptions
+    }),
     imports(),
     unicorn()
   );
   if (enableVue) {
     componentExts.push("vue");
   }
-  const {
-    enabled: tsEnabled = isPackageExists("typescript"),
-    ...tsParams
-  } = tsOptions;
-  if (tsEnabled) {
+  if (enableTypeScript) {
     configs.push(typescript({
-      ...tsParams,
-      componentExts,
-      overrides: overrides.typescript
+      ...resolveSubOptions(options, "typescript"),
+      componentExts
     }));
   }
   if (stylisticOptions) {
-    configs.push(stylistic());
+    configs.push(stylistic({
+      ...stylisticOptions,
+      overrides: getOverrides(options, "stylistic")
+    }));
   }
-  if (enableTest) {
+  if (options.test ?? true) {
     configs.push(test({
       isInEditor,
-      overrides: overrides.test
+      overrides: getOverrides(options, "test")
     }));
   }
-  ;
   if (enableVue) {
     configs.push(vue({
-      overrides: overrides.vue,
-      typescript: {
-        enabled: tsEnabled,
-        ...tsParams
-      }
+      ...resolveSubOptions(options, "vue"),
+      stylistic: stylisticOptions,
+      typescript: !!enableTypeScript
     }));
   }
-  ;
   if (enableReact) {
     configs.push(react({
-      overrides: overrides.react
+      overrides: getOverrides(options, "react"),
+      typescript: !!enableTypeScript
     }));
   }
   if (enableUnoCSS) {
-    configs.push(unocss(
-      isBoolean(enableUnoCSS) ? {} : enableUnoCSS
-    ));
+    configs.push(unocss({
+      ...resolveSubOptions(options, "unocss"),
+      overrides: getOverrides(options, "unocss")
+    }));
   }
-  if (enableJsonc) {
+  if (options.jsonc ?? true) {
     configs.push(
       jsonc({
-        overrides: overrides.jsonc,
+        overrides: getOverrides(options, "jsonc"),
         stylistic: stylisticOptions
       }),
       sortPackageJson(),
       sortTsconfig()
     );
   }
-  if (enableYaml) {
+  if (options.yaml ?? true) {
     configs.push(yaml({
-      overrides: overrides.yaml,
+      overrides: getOverrides(options, "yaml"),
       stylistic: stylisticOptions
     }));
   }
-  ;
-  if (enableMarkdown) {
-    configs.push(markdown({
-      componentExts,
-      overrides: overrides.markdown
-    }));
+  if (options.markdown ?? true) {
+    configs.push(
+      markdown(
+        {
+          componentExts,
+          overrides: getOverrides(options, "markdown")
+        }
+      )
+    );
+  }
+  if (options.formatters) {
+    configs.push(formatters(
+      options.formatters,
+      typeof stylisticOptions === "boolean" ? {} : stylisticOptions
+    ));
+  }
+  const fusedConfig = flatConfigProps.reduce((acc, key) => {
+    if (key in options) {
+      acc[key] = options[key];
+    }
+    ;
+    return acc;
+  }, {});
+  if (Object.keys(fusedConfig).length) {
+    configs.push([fusedConfig]);
   }
   ;
-  configs.push(ignores(options.ignores));
   return combineConfigs(
     ...configs,
     ...userConfigs
   );
 }
+function getOverrides(options, key) {
+  const sub = resolveSubOptions(options, key);
+  return {
+    ..."overrides" in sub ? sub.overrides : {}
+  };
+}
+function resolveSubOptions(options, key) {
+  return isBoolean(options[key]) ? {} : options[key] || {};
+}
 export {
+  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_MARKDOWN_IN_MARKDOWN,
+  GLOB_POSTCSS,
+  GLOB_SCSS,
   GLOB_SRC,
   GLOB_SRC_EXT,
+  GLOB_STYLE,
   GLOB_TESTS,
   GLOB_TS,
   GLOB_TSX,
   GLOB_VUE,
   GLOB_YAML,
+  STYLISTIC_CONFIG_DEFAULTS,
   combineConfigs,
   comments,
   ignores,
@@ -2748,6 +2901,7 @@ export {
   jsonc,
   markdown,
   node,
+  parserPlain,
   default3 as pluginComments,
   pluginImport,
   default4 as pluginNode,
@@ -2761,6 +2915,7 @@ export {
   sortTsconfig,
   stylistic,
   test,
+  toArray,
   typescript,
   unicorn,
   unocss,