@jiakun-zhao/eslint-config 3.1.0 → 4.0.1

package/dist/index.mjs

@@ -1,27 +1,991 @@
-import antfu from '@antfu/eslint-config';
-import { isPackageExists } from 'local-pkg';
-
-const index = antfu({
-  stylistic: {
-    overrides: {
-      "no-console": "warn",
-      // typescript
-      "ts/ban-ts-comment": "off",
-      // unused-imports
-      "unused-imports/no-unused-imports": "warn",
-      // jsx
-      "style/jsx-quotes": ["off", "prefer-single"],
-      "style/jsx-one-expression-per-line": "off"
+import { composer } from 'eslint-flat-config-utils';
+import pluginStylistic from '@stylistic/eslint-plugin';
+import pluginTypescript from '@typescript-eslint/eslint-plugin';
+import pluginAntfu from 'eslint-plugin-antfu';
+import pluginCommand from 'eslint-plugin-command';
+import pluginImportX from 'eslint-plugin-import-x';
+import pluginJsonc from 'eslint-plugin-jsonc';
+import pluginPerfectionist from 'eslint-plugin-perfectionist';
+import * as pluginRegExp from 'eslint-plugin-regexp';
+import pluginUnicorn from 'eslint-plugin-unicorn';
+import pluginUnusedImports from 'eslint-plugin-unused-imports';
+import gitignore from 'eslint-config-flat-gitignore';
+import globals from 'globals';
+
+const indent = 2;
+const ignores$1 = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.svelte-kit",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/vite.config.*.timestamp-*",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
+];
+const packageJsonTopLevelOrder = [
+  "publisher",
+  "name",
+  "displayName",
+  "type",
+  "version",
+  "private",
+  "packageManager",
+  "description",
+  "author",
+  "contributors",
+  "license",
+  "funding",
+  "homepage",
+  "repository",
+  "bugs",
+  "keywords",
+  "categories",
+  "sideEffects",
+  "exports",
+  "main",
+  "module",
+  "unpkg",
+  "jsdelivr",
+  "types",
+  "typesVersions",
+  "bin",
+  "icon",
+  "files",
+  "engines",
+  "activationEvents",
+  "contributes",
+  "scripts",
+  "peerDependencies",
+  "peerDependenciesMeta",
+  "dependencies",
+  "optionalDependencies",
+  "devDependencies",
+  "pnpm",
+  "overrides",
+  "resolutions",
+  "husky",
+  "simple-git-hooks",
+  "lint-staged",
+  "eslintConfig"
+];
+
+function antfu() {
+  return {
+    name: "antfu",
+    plugins: {
+      antfu: pluginAntfu
+    },
+    rules: {
+      "antfu/consistent-list-newline": ["warn", { JSXOpeningElement: false }],
+      "antfu/if-newline": "warn"
+    }
+  };
+}
+
+const tsParser = findParser(pluginTypescript);
+const jsoncParser = findParser(pluginJsonc);
+function findParser(plugin) {
+  const configs = Object.values(plugin.configs ?? {}).flat();
+  for (const config of configs) {
+    const parser = config.languageOptions?.parser;
+    if (parser)
+      return parser;
+  }
+  throw new Error(`Can not find parser in ${plugin.meta?.name}`);
+}
+async function findDynamicPlugin(name, key = "default") {
+  try {
+    return (await import(name))[key];
+  } catch {
+    return null;
+  }
+}
+function createRule(rule) {
+  const { name, ...rest } = rule;
+  rest.meta.docs ??= {};
+  rest.meta.docs.url = `https://example.com/${name}`;
+  return rest;
+}
+
+async function astro() {
+  const pluginAstro = await findDynamicPlugin("eslint-plugin-astro");
+  return pluginAstro && createSharedAstroConfig(pluginAstro, {
+    "mine/no-blank-before-astro-element": "warn",
+    "mine/no-blank-in-astro-frontmatter-start": "warn"
+  });
+}
+function createSharedAstroConfig(plugin, rules = {}) {
+  return {
+    files: [
+      "**/*.astro"
+    ],
+    languageOptions: {
+      parser: findParser(plugin),
+      parserOptions: {
+        extraFileExtensions: [
+          ".astro"
+        ],
+        parser: tsParser
+      }
+    },
+    name: "astro",
+    plugins: {
+      astro: plugin
+    },
+    rules
+  };
+}
+
+function command() {
+  return {
+    name: "command",
+    plugins: {
+      command: pluginCommand
+    },
+    rules: {
+      "command/command": "warn"
+    }
+  };
+}
+
+function ignores(options) {
+  return [
+    gitignore({ ...options.gitignore, name: "ignores/gitignore" }),
+    { ignores: ignores$1, name: "ignores/antfu" },
+    options.ignores && { ignores: options.ignores, name: "ignores" }
+  ];
+}
+
+function importX() {
+  return {
+    name: "import-x",
+    plugins: {
+      "import-x": pluginImportX
+    },
+    rules: {
+      "import-x/consistent-type-specifier-style": ["warn", "prefer-top-level"],
+      "import-x/first": "warn",
+      "import-x/newline-after-import": ["warn", { count: 1 }],
+      "import-x/no-duplicates": "warn",
+      "import-x/no-mutable-exports": "warn",
+      "import-x/no-named-default": "warn",
+      "import-x/no-self-import": "warn",
+      "import-x/no-webpack-loader-syntax": "warn"
+    }
+  };
+}
+
+function javascript() {
+  return {
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        ...globals.browser,
+        ...globals.es2021,
+        ...globals.node,
+        document: "readonly",
+        navigator: "readonly",
+        window: "readonly"
+      },
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        },
+        ecmaVersion: 2022,
+        sourceType: "module"
+      },
+      sourceType: "module"
+    },
+    name: "javascript",
+    rules: {
+      "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 }],
+      "no-alert": "error",
+      "no-array-constructor": "error",
+      "no-async-promise-executor": "error",
+      "no-caller": "error",
+      "no-case-declarations": "error",
+      "no-class-assign": "error",
+      "no-compare-neg-zero": "error",
+      "no-cond-assign": ["error", "always"],
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+      "no-const-assign": "error",
+      "no-control-regex": "error",
+      "no-debugger": "error",
+      "no-delete-var": "error",
+      "no-dupe-args": "error",
+      "no-dupe-class-members": "error",
+      "no-dupe-keys": "error",
+      "no-duplicate-case": "error",
+      "no-empty": ["error", { allowEmptyCatch: true }],
+      "no-empty-character-class": "error",
+      "no-empty-pattern": "error",
+      "no-eval": "error",
+      "no-ex-assign": "error",
+      "no-extend-native": "error",
+      "no-extra-bind": "error",
+      "no-extra-boolean-cast": "error",
+      "no-fallthrough": "error",
+      "no-func-assign": "error",
+      "no-global-assign": "error",
+      "no-implied-eval": "error",
+      "no-import-assign": "error",
+      "no-invalid-regexp": "error",
+      "no-irregular-whitespace": "error",
+      "no-iterator": "error",
+      "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
+      "no-lone-blocks": "error",
+      "no-loss-of-precision": "error",
+      "no-misleading-character-class": "error",
+      "no-multi-str": "error",
+      "no-new": "error",
+      "no-new-func": "error",
+      "no-new-native-nonconstructor": "error",
+      "no-new-wrappers": "error",
+      "no-obj-calls": "error",
+      "no-octal": "error",
+      "no-octal-escape": "error",
+      "no-proto": "error",
+      "no-prototype-builtins": "error",
+      "no-redeclare": ["error", { builtinGlobals: false }],
+      "no-regex-spaces": "error",
+      "no-restricted-globals": [
+        "error",
+        { message: "Use `globalThis` instead.", name: "global" },
+        { message: "Use `globalThis` instead.", name: "self" }
+      ],
+      "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__" }
+      ],
+      "no-restricted-syntax": ["error", "TSEnumDeclaration[const=true]", "TSExportAssignment"],
+      "no-self-assign": ["error", { props: true }],
+      "no-self-compare": "error",
+      "no-sequences": "error",
+      "no-shadow-restricted-names": "error",
+      "no-sparse-arrays": "error",
+      "no-template-curly-in-string": "error",
+      "no-this-before-super": "error",
+      "no-throw-literal": "error",
+      "no-undef": "error",
+      "no-undef-init": "error",
+      "no-unexpected-multiline": "error",
+      "no-unmodified-loop-condition": "error",
+      "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+      "no-unreachable": "error",
+      "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-useless-backreference": "error",
+      "no-useless-call": "error",
+      "no-useless-catch": "error",
+      "no-useless-computed-key": "error",
+      "no-useless-constructor": "error",
+      "no-useless-rename": "error",
+      "no-useless-return": "error",
+      "no-var": "error",
+      "no-with": "error",
+      "object-shorthand": ["error", "always", { avoidQuotes: true, ignoreConstructors: false }],
+      "one-var": ["error", { initialized: "never" }],
+      "prefer-arrow-callback": ["error", { allowNamedFunctions: false, allowUnboundThis: true }],
+      "prefer-const": "warn",
+      "prefer-exponentiation-operator": "error",
+      "prefer-promise-reject-errors": "error",
+      "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+      "prefer-rest-params": "error",
+      "prefer-spread": "error",
+      "prefer-template": "error",
+      "symbol-description": "error",
+      "unicode-bom": ["error", "never"],
+      "use-isnan": ["error", { enforceForIndexOf: true, enforceForSwitchCase: true }],
+      "valid-typeof": ["error", { requireStringLiterals: true }],
+      "vars-on-top": "error",
+      "yoda": ["error", "never"]
+    }
+  };
+}
+
+function jsonc() {
+  return [
+    {
+      files: [
+        "**/*.json",
+        "**/*.jsonc",
+        "**/*.json5"
+      ],
+      languageOptions: {
+        parser: jsoncParser
+      },
+      name: "jsonc",
+      plugins: {
+        jsonc: pluginJsonc
+      },
+      rules: {
+        "jsonc/array-bracket-newline": ["warn", "consistent"],
+        "jsonc/array-bracket-spacing": ["warn", "never"],
+        "jsonc/array-element-newline": ["warn", "consistent"],
+        "jsonc/comma-dangle": ["warn", "never"],
+        "jsonc/comma-style": ["warn", "last"],
+        "jsonc/indent": ["warn", indent],
+        "jsonc/key-spacing": "warn",
+        "jsonc/no-sparse-arrays": "warn",
+        "jsonc/object-curly-newline": ["warn", { consistent: true }],
+        "jsonc/object-curly-spacing": ["warn", "always"]
+      }
+    }
+  ];
+}
+
+const version = "4.0.1";
+
+const toString = (v) => Object.prototype.toString.call(v);
+const isNull = (val) => toString(val) === "[object Null]";
+
+function isFileStart(node) {
+  return node.range[0] === 0;
+}
+function isLineStart(node) {
+  return node.loc.start.column === 0;
+}
+function numOfBlankLines(left, right) {
+  return right.loc.start.line - left.loc.end.line;
+}
+function isFrontmatterToken(token) {
+  return token?.value === "---";
+}
+
+const name$2 = "no-blank-before-astro-element";
+const _noBlankBeforeAstroElement = createRule({
+  name: name$2,
+  meta: {
+    docs: {
+      description: "Enforce no blank before astro element"
+    },
+    schema: [],
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      unexpectedBlank: "Unexpected blank"
     }
   },
-  vue: {
-    overrides: {
-      "vue/html-self-closing": "off",
-      "vue/singleline-html-element-content-newline": "off",
-      "vue/static-class-names-order": "warn"
+  create(context) {
+    return {
+      AstroFragment(node) {
+        const token = context.sourceCode.getTokenBefore(node);
+        if (isNull(token) && !isFileStart(node)) {
+          context.report({
+            fix: (fixer) => fixer.removeRange([0, node.range[0]]),
+            loc: { start: { line: 1, column: 0 }, end: node.loc.start },
+            messageId: "unexpectedBlank"
+          });
+        } else if (isFrontmatterToken(token) && (!isLineStart(node) || numOfBlankLines(token, node) !== 2)) {
+          context.report({
+            fix: (fixer) => fixer.replaceTextRange([token.range[1], node.range[0]], "\n\n"),
+            loc: { start: token.loc.end, end: node.loc.start },
+            messageId: "unexpectedBlank"
+          });
+        }
+      }
+    };
+  }
+});
+
+const name$1 = "no-blank-in-astro-frontmatter-start";
+const _noBlankInAstroFrontmatterStart = createRule({
+  name: name$1,
+  meta: {
+    docs: {
+      description: "Enforce no blank in astro frontmatter start"
+    },
+    schema: [],
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      unexpectedBlank: "Unexpected blank"
     }
   },
-  astro: isPackageExists("eslint-plugin-astro")
+  create(context) {
+    return {
+      Program(node) {
+        const [first, next] = context.sourceCode.getFirstTokens(node, { count: 2 });
+        if (isFrontmatterToken(first) && next && next.loc.start.line !== 2) {
+          context.report({
+            fix: (fixer) => fixer.replaceTextRange([3, next.range[0]], "\n"),
+            loc: { start: { line: 1, column: 0 }, end: next.loc.start },
+            messageId: "unexpectedBlank"
+          });
+        }
+      }
+    };
+  }
 });
 
+const name = "no-space-in-empty-block";
+const _noSpaceInEmptyObject = createRule({
+  name,
+  meta: {
+    docs: {
+      description: "Enforce no space in empty object"
+    },
+    schema: [],
+    type: "layout",
+    fixable: "whitespace",
+    messages: {
+      unexpectedSpace: "Unexpected space in empty object"
+    }
+  },
+  create(context) {
+    return {
+      ObjectExpression(node) {
+        if (node.properties.length)
+          return;
+        const code = context.sourceCode.getText(node);
+        const replaceValue = "{}";
+        if (code !== replaceValue) {
+          context.report({
+            fix: (fixer) => fixer.replaceText(node, replaceValue),
+            messageId: "unexpectedSpace",
+            node
+          });
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration || node.specifiers.length) {
+          return;
+        }
+        const code = context.sourceCode.getText(node);
+        const replaceValue = "export {}";
+        if (code !== replaceValue) {
+          context.report({
+            fix: (fixer) => fixer.replaceText(node, replaceValue),
+            messageId: "unexpectedSpace",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+const rules = {
+  [name]: _noSpaceInEmptyObject,
+  [name$2]: _noBlankBeforeAstroElement,
+  [name$1]: _noBlankInAstroFrontmatterStart
+};
+const pluginMine = {
+  meta: {
+    name: "mine",
+    version
+  },
+  rules
+};
+
+function mine() {
+  return {
+    name: "mine",
+    plugins: {
+      mine: pluginMine
+    },
+    rules: {
+      "mine/no-space-in-empty-block": "warn"
+    }
+  };
+}
+
+function overrides() {
+  const configFileNames = ["eslint", "astro", "vite", "build", "uno", "unocss", "vitest"];
+  const extensions = ["js", "mjs", "cjs", "ts", "mts", "cts"];
+  return [
+    {
+      name: "override/sort-config-files",
+      files: [
+        ...configFileNames.reduce(
+          (acc, cur) => acc.concat(...extensions.map((ext) => `${cur}.config.${ext}`)),
+          []
+        )
+      ],
+      rules: {
+        "perfectionist/sort-objects": "warn"
+      }
+    },
+    {
+      name: "override/jsonc-sort",
+      files: [
+        "**/.vscode/settings.json",
+        "**/tsconfig.json"
+      ],
+      rules: {
+        "jsonc/sort-array-values": ["warn", { order: { type: "asc" }, pathPattern: ".*" }],
+        "jsonc/sort-keys": ["warn", { order: { type: "asc" }, pathPattern: ".*" }]
+      }
+    },
+    {
+      name: "override/package-json",
+      files: [
+        "**/package.json"
+      ],
+      rules: {
+        "style/no-multiple-empty-lines": ["warn", { max: 0 }],
+        "jsonc/sort-array-values": [
+          "warn",
+          { order: { type: "asc" }, pathPattern: "^files$" }
+        ],
+        "jsonc/sort-keys": [
+          "warn",
+          { order: packageJsonTopLevelOrder, pathPattern: "^$" },
+          { order: { type: "asc" }, pathPattern: "^(?:exports|scripts)" },
+          /* cSpell:disable-next-line */
+          { order: { type: "asc" }, pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies(Meta)?$" }
+        ]
+      }
+    }
+  ];
+}
+
+function perfectionist() {
+  return {
+    name: "perfectionist",
+    plugins: {
+      perfectionist: pluginPerfectionist
+    },
+    rules: {
+      "perfectionist/sort-exports": ["warn", { order: "asc", type: "natural" }],
+      "perfectionist/sort-imports": ["warn", {
+        groups: ["type", ["parent-type", "sibling-type", "index-type", "internal-type"], "builtin", "external", "internal", ["parent", "sibling", "index"], "side-effect", "object", "unknown"],
+        newlinesBetween: "ignore",
+        order: "asc",
+        type: "natural"
+      }],
+      "perfectionist/sort-named-exports": ["warn", { order: "asc", type: "natural" }],
+      "perfectionist/sort-named-imports": ["warn", { order: "asc", type: "natural" }]
+    }
+  };
+}
+
+function regexp() {
+  return {
+    name: "regexp",
+    plugins: {
+      regexp: pluginRegExp
+    },
+    rules: {
+      "no-control-regex": "warn",
+      "no-empty-character-class": "off",
+      "no-invalid-regexp": "off",
+      "no-misleading-character-class": "warn",
+      "no-regex-spaces": "warn",
+      "no-useless-backreference": "off",
+      "prefer-regex-literals": "warn",
+      "regexp/confusing-quantifier": "warn",
+      "regexp/control-character-escape": "warn",
+      "regexp/match-any": "warn",
+      "regexp/negation": "warn",
+      "regexp/no-contradiction-with-assertion": "warn",
+      "regexp/no-dupe-characters-character-class": "warn",
+      "regexp/no-dupe-disjunctions": "warn",
+      "regexp/no-empty-alternative": "warn",
+      "regexp/no-empty-capturing-group": "warn",
+      "regexp/no-empty-character-class": "warn",
+      "regexp/no-empty-group": "warn",
+      "regexp/no-empty-lookarounds-assertion": "warn",
+      "regexp/no-empty-string-literal": "warn",
+      "regexp/no-escape-backspace": "warn",
+      "regexp/no-extra-lookaround-assertions": "warn",
+      "regexp/no-invalid-regexp": "warn",
+      "regexp/no-invisible-character": "warn",
+      "regexp/no-lazy-ends": "warn",
+      "regexp/no-legacy-features": "warn",
+      "regexp/no-misleading-capturing-group": "warn",
+      "regexp/no-misleading-unicode-character": "warn",
+      "regexp/no-missing-g-flag": "warn",
+      "regexp/no-non-standard-flag": "warn",
+      "regexp/no-obscure-range": "warn",
+      "regexp/no-optional-assertion": "warn",
+      "regexp/no-potentially-useless-backreference": "warn",
+      "regexp/no-super-linear-backtracking": "warn",
+      "regexp/no-trivially-nested-assertion": "warn",
+      "regexp/no-trivially-nested-quantifier": "warn",
+      "regexp/no-unused-capturing-group": "warn",
+      "regexp/no-useless-assertions": "warn",
+      "regexp/no-useless-backreference": "warn",
+      "regexp/no-useless-character-class": "warn",
+      "regexp/no-useless-dollar-replacements": "warn",
+      "regexp/no-useless-escape": "warn",
+      "regexp/no-useless-flag": "warn",
+      "regexp/no-useless-lazy": "warn",
+      "regexp/no-useless-non-capturing-group": "warn",
+      "regexp/no-useless-quantifier": "warn",
+      "regexp/no-useless-range": "warn",
+      "regexp/no-useless-set-operand": "warn",
+      "regexp/no-useless-string-literal": "warn",
+      "regexp/no-useless-two-nums-quantifier": "warn",
+      "regexp/no-zero-quantifier": "warn",
+      "regexp/optimal-lookaround-quantifier": "warn",
+      "regexp/optimal-quantifier-concatenation": "warn",
+      "regexp/prefer-character-class": "warn",
+      "regexp/prefer-d": "warn",
+      "regexp/prefer-plus-quantifier": "warn",
+      "regexp/prefer-predefined-assertion": "warn",
+      "regexp/prefer-question-quantifier": "warn",
+      "regexp/prefer-range": "warn",
+      "regexp/prefer-set-operation": "warn",
+      "regexp/prefer-star-quantifier": "warn",
+      "regexp/prefer-unicode-codepoint-escapes": "warn",
+      "regexp/prefer-w": "warn",
+      "regexp/simplify-set-operations": "warn",
+      "regexp/sort-flags": "warn",
+      "regexp/strict": "warn",
+      "regexp/use-ignore-case": "warn"
+    }
+  };
+}
+
+function stylistic() {
+  return {
+    name: "stylistic",
+    plugins: {
+      style: pluginStylistic
+    },
+    rules: {
+      "style/array-bracket-newline": ["warn", "consistent"],
+      "style/array-bracket-spacing": "warn",
+      "style/arrow-spacing": "warn",
+      "style/block-spacing": "warn",
+      "style/comma-dangle": ["warn", "always-multiline"],
+      "style/comma-spacing": "warn",
+      "style/comma-style": "warn",
+      "style/curly-newline": "warn",
+      "style/eol-last": "warn",
+      "style/function-call-spacing": "warn",
+      "style/implicit-arrow-linebreak": "warn",
+      "style/indent": ["warn", indent],
+      "style/indent-binary-ops": ["warn", indent],
+      "style/jsx-child-element-spacing": "warn",
+      "style/jsx-closing-bracket-location": "warn",
+      "style/jsx-closing-tag-location": "warn",
+      "style/jsx-curly-brace-presence": "warn",
+      "style/jsx-curly-newline": "warn",
+      "style/jsx-curly-spacing": ["warn", { children: { when: "always" }, when: "never" }],
+      "style/jsx-equals-spacing": "warn",
+      "style/jsx-max-props-per-line": "off",
+      "style/jsx-pascal-case": "warn",
+      "style/jsx-quotes": "warn",
+      "style/jsx-self-closing-comp": ["warn", { component: true, html: false }],
+      "style/jsx-tag-spacing": "warn",
+      "style/jsx-wrap-multilines": "warn",
+      "style/key-spacing": "warn",
+      "style/keyword-spacing": "warn",
+      "style/no-mixed-spaces-and-tabs": "warn",
+      "style/no-multi-spaces": "warn",
+      "style/no-multiple-empty-lines": ["warn", { max: 1, maxBOF: 0, maxEOF: 0 }],
+      "style/no-trailing-spaces": "warn",
+      "style/no-whitespace-before-property": "warn",
+      "style/nonblock-statement-body-position": ["warn", "below"],
+      "style/object-curly-newline": ["warn", { consistent: true }],
+      "style/object-curly-spacing": ["warn", "always"],
+      "style/operator-linebreak": ["warn", "before"],
+      "style/quote-props": ["warn", "consistent-as-needed"],
+      "style/quotes": ["warn", "single"],
+      "style/rest-spread-spacing": "warn",
+      "style/semi": ["warn", "never"],
+      "style/semi-spacing": "warn",
+      "style/space-before-blocks": "warn",
+      "style/space-before-function-paren": ["warn", "never"],
+      "style/space-in-parens": "warn",
+      "style/space-infix-ops": "warn",
+      "style/space-unary-ops": "warn",
+      "style/spaced-comment": ["warn", "always", { block: { balanced: true } }],
+      "style/type-annotation-spacing": "warn",
+      "style/type-generic-spacing": "warn",
+      "style/type-named-tuple-spacing": "warn"
+    }
+  };
+}
+
+function typescript() {
+  return [
+    {
+      files: [
+        "**/*.?([cm])ts",
+        "**/*.?([cm])tsx",
+        "**/*.vue"
+      ],
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          extraFileExtensions: [".vue"],
+          sourceType: "module"
+        }
+      },
+      name: "typescript",
+      plugins: {
+        ts: pluginTypescript
+      },
+      rules: {
+        "constructor-super": "off",
+        "getter-return": "off",
+        "no-array-constructor": "off",
+        "no-class-assign": "off",
+        "no-const-assign": "off",
+        "no-dupe-args": "off",
+        "no-dupe-class-members": "off",
+        "no-dupe-keys": "off",
+        "no-func-assign": "off",
+        "no-import-assign": "off",
+        "no-new-native-nonconstructor": "off",
+        "no-new-symbol": "off",
+        "no-obj-calls": "off",
+        "no-redeclare": "off",
+        "no-setter-return": "off",
+        "no-this-before-super": "off",
+        "no-undef": "off",
+        "no-unreachable": "off",
+        "no-unsafe-negation": "off",
+        "no-unused-expressions": "off",
+        "no-unused-vars": "off",
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "no-var": "error",
+        "no-with": "off",
+        "prefer-const": "error",
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "ts/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+        "ts/consistent-type-definitions": ["error", "interface"],
+        "ts/consistent-type-imports": ["error", { disallowTypeAnnotations: false, fixStyle: "separate-type-imports", prefer: "type-imports" }],
+        "ts/explicit-function-return-type": "off",
+        "ts/method-signature-style": ["error", "property"],
+        "ts/no-array-constructor": "error",
+        "ts/no-dupe-class-members": "error",
+        "ts/no-duplicate-enum-values": "error",
+        "ts/no-dynamic-delete": "off",
+        "ts/no-empty-object-type": ["error", { allowInterfaces: "always" }],
+        "ts/no-explicit-any": "off",
+        "ts/no-extra-non-null-assertion": "error",
+        "ts/no-extraneous-class": "off",
+        "ts/no-import-type-side-effects": "error",
+        "ts/no-invalid-void-type": "off",
+        "ts/no-misused-new": "error",
+        "ts/no-namespace": "error",
+        "ts/no-non-null-asserted-nullish-coalescing": "error",
+        "ts/no-non-null-asserted-optional-chain": "error",
+        "ts/no-non-null-assertion": "off",
+        "ts/no-redeclare": ["error", { builtinGlobals: false }],
+        "ts/no-require-imports": "error",
+        "ts/no-this-alias": "error",
+        "ts/no-unnecessary-type-constraint": "error",
+        "ts/no-unsafe-declaration-merging": "error",
+        "ts/no-unsafe-function-type": "error",
+        "ts/no-unused-expressions": ["error", { allowShortCircuit: true, allowTaggedTemplates: true, allowTernary: true }],
+        "ts/no-unused-vars": "off",
+        "ts/no-use-before-define": ["error", { classes: false, functions: false, variables: true }],
+        "ts/no-useless-constructor": "off",
+        "ts/no-wrapper-object-types": "error",
+        "ts/prefer-as-const": "error",
+        "ts/prefer-literal-enum-member": "error",
+        "ts/prefer-namespace-keyword": "error",
+        "ts/triple-slash-reference": "off",
+        "ts/unified-signatures": "off"
+      }
+    }
+  ];
+}
+
+function unicorn() {
+  return {
+    name: "unicorn",
+    plugins: {
+      unicorn: pluginUnicorn
+    },
+    rules: {
+      "unicorn/consistent-empty-array-spread": "warn",
+      "unicorn/error-message": "warn",
+      "unicorn/escape-case": "warn",
+      "unicorn/new-for-builtins": "warn",
+      "unicorn/no-instanceof-builtins": "warn",
+      "unicorn/no-new-array": "warn",
+      "unicorn/no-new-buffer": "warn",
+      "unicorn/number-literal-case": "warn",
+      "unicorn/prefer-dom-node-text-content": "warn",
+      "unicorn/prefer-includes": "warn",
+      "unicorn/prefer-node-protocol": "warn",
+      "unicorn/prefer-number-properties": "warn",
+      "unicorn/prefer-string-starts-ends-with": "warn",
+      "unicorn/prefer-type-error": "warn",
+      "unicorn/throw-new-error": "warn"
+    }
+  };
+}
+
+function unusedImports() {
+  return {
+    name: "unused-imports",
+    plugins: {
+      "unused-imports": pluginUnusedImports
+    },
+    rules: {
+      "unused-imports/no-unused-imports": "warn",
+      "unused-imports/no-unused-vars": [
+        "warn",
+        {
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          ignoreRestSiblings: true,
+          vars: "all",
+          varsIgnorePattern: "^_"
+        }
+      ]
+    }
+  };
+}
+
+async function vue() {
+  const pluginVue = await findDynamicPlugin("eslint-plugin-vue");
+  return pluginVue && {
+    files: [
+      "**/*.vue"
+    ],
+    languageOptions: {
+      parser: findParser(pluginVue),
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        },
+        extraFileExtensions: [
+          ".vue"
+        ],
+        globals: {
+          computed: "readonly",
+          defineEmits: "readonly",
+          defineExpose: "readonly",
+          defineProps: "readonly",
+          onMounted: "readonly",
+          onUnmounted: "readonly",
+          reactive: "readonly",
+          ref: "readonly",
+          shallowReactive: "readonly",
+          shallowRef: "readonly",
+          toRef: "readonly",
+          toRefs: "readonly",
+          watch: "readonly",
+          watchEffect: "readonly"
+        },
+        parser: tsParser,
+        sourceType: "module"
+      }
+    },
+    name: "vue",
+    plugins: {
+      vue: pluginVue
+    },
+    processor: pluginVue.processors?.[".vue"],
+    rules: {
+      ...pluginVue.configs["flat/essential"].map((c) => c.rules).reduce((acc, cur) => ({ ...acc, ...cur }), {}),
+      "vue/attribute-hyphenation": "warn",
+      "vue/attributes-order": ["warn", { alphabetical: true, order: ["UNIQUE", "DEFINITION", "CONDITIONALS", "LIST_RENDERING", "GLOBAL", "RENDER_MODIFIERS", "SLOT", "TWO_WAY_BINDING", "OTHER_DIRECTIVES", "CONTENT", "ATTR_SHORTHAND_BOOL", "ATTR_STATIC", "ATTR_DYNAMIC", "EVENTS"] }],
+      "vue/block-order": "warn",
+      "vue/block-tag-newline": "warn",
+      "vue/component-name-in-template-casing": "warn",
+      "vue/component-options-name-casing": ["warn", "PascalCase"],
+      "vue/custom-event-name-casing": ["warn", "kebab-case"],
+      "vue/define-emits-declaration": "warn",
+      "vue/define-macros-order": "warn",
+      "vue/define-props-declaration": "warn",
+      "vue/first-attribute-linebreak": "warn",
+      "vue/html-button-has-type": "warn",
+      "vue/html-closing-bracket-newline": "warn",
+      "vue/html-closing-bracket-spacing": "warn",
+      "vue/html-comment-content-newline": "warn",
+      "vue/html-comment-content-spacing": "warn",
+      "vue/html-comment-indent": ["warn", indent],
+      "vue/html-indent": ["warn", indent],
+      "vue/html-quotes": "warn",
+      "vue/html-self-closing": ["warn", { html: { component: "always", normal: "never", void: "never" }, math: "always", svg: "always" }],
+      "vue/mustache-interpolation-spacing": "warn",
+      "vue/no-import-compiler-macros": "warn",
+      "vue/no-multi-spaces": "warn",
+      "vue/no-ref-object-reactivity-loss": "warn",
+      "vue/no-spaces-around-equal-signs-in-attribute": "warn",
+      "vue/no-static-inline-styles": "warn",
+      "vue/no-template-shadow": "warn",
+      "vue/no-template-target-blank": "warn",
+      "vue/no-unused-refs": "warn",
+      "vue/no-use-v-else-with-v-for": "warn",
+      "vue/no-useless-mustaches": "warn",
+      "vue/no-useless-v-bind": "warn",
+      "vue/padding-line-between-blocks": "warn",
+      "vue/prefer-separate-static-class": "warn",
+      "vue/prefer-true-attribute-shorthand": "warn",
+      "vue/prefer-use-template-ref": "warn",
+      "vue/require-macro-variable-name": "warn",
+      "vue/require-typed-ref": "warn",
+      "vue/slot-name-casing": ["warn", "kebab-case"],
+      "vue/static-class-names-order": "warn",
+      "vue/v-bind-style": ["wran", "shorthand", { sameNameShorthand: "always" }],
+      "vue/v-for-delimiter-style": ["warn", "of"],
+      "vue/v-on-event-hyphenation": "warn",
+      "vue/v-on-handler-style": "warn",
+      "vue/v-on-style": "warn",
+      "vue/v-slot-style": "warn"
+    }
+  };
+}
+
+function index(options = {}) {
+  return composer(
+    ignores(options),
+    jsonc(),
+    javascript(),
+    typescript(),
+    astro(),
+    vue(),
+    stylistic(),
+    mine(),
+    unusedImports(),
+    perfectionist(),
+    antfu(),
+    importX(),
+    unicorn(),
+    regexp(),
+    command(),
+    overrides()
+  );
+}
+
 export { index as default };