@unshared/eslint-config 0.2.3 → 0.3.1

package/dist/configs.js

@@ -0,0 +1,1148 @@
+import pluginAntfu from "eslint-plugin-antfu";
+import eslintCommentsPlugin from "eslint-plugin-eslint-comments";
+import pluginJsdoc from "eslint-plugin-jsdoc";
+import pluginJsonc from "eslint-plugin-jsonc";
+import nodePlugin from "eslint-plugin-n";
+import pluginSonarjs from "eslint-plugin-sonarjs";
+import javascript from "@eslint/js";
+import stylistic from "@stylistic/eslint-plugin";
+import { toArray } from "@unshared/collection/toArray";
+import perfectionist from "eslint-plugin-perfectionist";
+import tslint from "typescript-eslint";
+import { getConfigRules } from "./utils.js";
+import unicornPlugin from "eslint-plugin-unicorn";
+import vitestPlugin from "@vitest/eslint-plugin";
+import { mergeProcessors } from "eslint-merge-processors";
+import vuePlugin from "eslint-plugin-vue";
+import vueProcessorBlocks from "eslint-processor-vue-blocks";
+import vueParser from "vue-eslint-parser";
+import pluginYml from "eslint-plugin-yml";
+function antfu() {
+  return [
+    {
+      plugins: {
+        antfu: pluginAntfu
+      },
+      rules: {
+        // --- Enforce consistent line breaks for chaining member access.
+        "antfu/consistent-chaining": "error",
+        // --- Enforce consistent line breaks inside braces of object/array/named imports/exports and function parameters.
+        "antfu/consistent-list-newline": "error",
+        // --- Deduplicate imports.
+        "antfu/import-dedupe": "error",
+        // --- Avoid importing from 'dist' directories.
+        "antfu/no-import-dist": "error",
+        // --- Enforce `export default` insteand of `export = {}`.
+        "antfu/no-ts-export-equal": "error",
+        // --- Enforce `function()` instead of `() => {}` for top-level functions.
+        "antfu/top-level-function": "error"
+      }
+    }
+  ];
+}
+function eslintComments() {
+  return [
+    {
+      plugins: {
+        "eslint-comments": eslintCommentsPlugin
+      },
+      rules: {
+        // --- Allow disable without having to enable again.
+        "eslint-comments/disable-enable-pair": "off",
+        // --- Disallow eslint-disable comments without rule names. This ensures that we cannot
+        "eslint-comments/no-aggregating-enable": "error",
+        // --- Disable must specify rule names.
+        "eslint-comments/no-unlimited-disable": "error",
+        // --- Prevent superfluous eslint comments.
+        "eslint-comments/no-duplicate-disable": "error",
+        "eslint-comments/no-unused-disable": "error",
+        "eslint-comments/no-unused-enable": "error"
+      }
+    }
+  ];
+}
+function jsdoc() {
+  return [
+    pluginJsdoc.configs["flat/recommended-typescript-error"],
+    {
+      files: [
+        "**/*.{ts,mts,cts,tsx,d.ts}",
+        "**/*.{js,mjs,cjs,jsx}",
+        "**/*.vue"
+      ],
+      plugins: {
+        jsdoc: pluginJsdoc
+      },
+      rules: {
+        // --- Redudant with TypeScript.
+        "jsdoc/require-jsdoc": "off",
+        "jsdoc/require-param-type": "off",
+        "jsdoc/require-returns-type": "off",
+        // --- Reports malformed JSDoc comments.
+        "jsdoc/no-bad-blocks": "error",
+        "jsdoc/check-alignment": "error",
+        "jsdoc/check-indentation": "error",
+        // --- Reports invalid block tag names.
+        "jsdoc/check-tag-names": ["error", { definedTags: ["category"] }],
+        // --- Do not use hyphens before param descriptions.
+        "jsdoc/require-hyphen-before-param-description": ["error", "never"],
+        // --- Newline after description.
+        "jsdoc/tag-lines": ["error", "any", { startLines: 1 }]
+      }
+    }
+  ];
+}
+function json() {
+  return [
+    ...pluginJsonc.configs["flat/recommended-with-json"],
+    {
+      rules: {
+        // --- Automatically apply jsonc rules similar to your configured ESLint core rules to JSON.
+        "jsonc/auto": "error"
+      }
+    }
+  ];
+}
+function jsonPackage() {
+  return [
+    {
+      files: [
+        "**/package.json"
+      ],
+      rules: {
+        "jsonc/sort-keys": [
+          "error",
+          {
+            order: [
+              "name",
+              "type",
+              "version",
+              "license",
+              "private",
+              "sideEffects",
+              // --- Publishing
+              "description",
+              "author",
+              "keywords",
+              "bugs",
+              "funding",
+              "homepage",
+              "repository",
+              // --- Distribution
+              "bin",
+              "main",
+              "module",
+              "types",
+              "typings",
+              "browser",
+              "exports",
+              "files",
+              // --- Package Manager
+              "packageManager",
+              "pnpm",
+              // --- Scripts
+              "scripts",
+              // --- Dependencies
+              "peerDependencies",
+              "peerDependenciesMeta",
+              "optionalDependencies",
+              "dependencies",
+              "devDependencies",
+              "bundledDependencies",
+              "bundleDependencies",
+              // --- Config
+              "tsup",
+              "husky",
+              "lint-staged",
+              "eslintConfig"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: "^(?:dev|peer|optional|bundled)?[Dd]ependencies$"
+          }
+        ]
+      }
+    }
+  ];
+}
+function jsonTsconfig() {
+  return [
+    {
+      files: [
+        "**/tsconfig.json",
+        "**/tsconfig.*.json"
+      ],
+      rules: {
+        "jsonc/sort-array-values": [
+          "error",
+          {
+            order: { type: "asc" },
+            pathPattern: "^(includes|excludes)$"
+          }
+        ],
+        "jsonc/sort-keys": [
+          "error",
+          {
+            order: [
+              "extends",
+              "compilerOptions",
+              "references",
+              "files",
+              "include",
+              "exclude"
+            ],
+            pathPattern: "^$"
+          },
+          {
+            order: [
+              // --- Project Structure
+              "incremental",
+              "composite",
+              "tsBuildInfoFile",
+              "disableSourceOfProjectReferenceRedirect",
+              "disableSolutionSearching",
+              "disableReferencedProjectLoad",
+              // --- Language and Environment
+              "target",
+              "jsx",
+              "jsxFactory",
+              "jsxFragmentFactory",
+              "jsxImportSource",
+              "lib",
+              "moduleDetection",
+              "noLib",
+              "reactNamespace",
+              "useDefineForClassFields",
+              "emitDecoratorMetadata",
+              "experimentalDecorators",
+              // --- Module Resolution
+              "baseUrl",
+              "rootDir",
+              "rootDirs",
+              "customConditions",
+              "module",
+              "moduleResolution",
+              "moduleSuffixes",
+              "noResolve",
+              "paths",
+              "resolveJsonModule",
+              "resolvePackageJsonExports",
+              "resolvePackageJsonImports",
+              "typeRoots",
+              "types",
+              "allowArbitraryExtensions",
+              "allowImportingTsExtensions",
+              "allowUmdGlobalAccess",
+              // --- JavaScript Support
+              "allowJs",
+              "checkJs",
+              "maxNodeModuleJsDepth",
+              // --- Type Checking
+              "strict",
+              "strictBindCallApply",
+              "strictFunctionTypes",
+              "strictNullChecks",
+              "strictPropertyInitialization",
+              "allowUnreachableCode",
+              "allowUnusedLabels",
+              "alwaysStrict",
+              "exactOptionalPropertyTypes",
+              "noFallthroughCasesInSwitch",
+              "noImplicitAny",
+              "noImplicitOverride",
+              "noImplicitReturns",
+              "noImplicitThis",
+              "noPropertyAccessFromIndexSignature",
+              "noUncheckedIndexedAccess",
+              "noUnusedLocals",
+              "noUnusedParameters",
+              "useUnknownInCatchVariables",
+              // --- Emitting
+              "declaration",
+              "declarationDir",
+              "declarationMap",
+              "downlevelIteration",
+              "emitBOM",
+              "emitDeclarationOnly",
+              "importHelpers",
+              "importsNotUsedAsValues",
+              "inlineSourceMap",
+              "inlineSources",
+              "mapRoot",
+              "newLine",
+              "noEmit",
+              "noEmitHelpers",
+              "noEmitOnError",
+              "outDir",
+              "outFile",
+              "preserveConstEnums",
+              "preserveValueImports",
+              "removeComments",
+              "sourceMap",
+              "sourceRoot",
+              "stripInternal",
+              // --- Interop Constraints
+              "allowSyntheticDefaultImports",
+              "esModuleInterop",
+              "forceConsistentCasingInFileNames",
+              "isolatedModules",
+              "preserveSymlinks",
+              "verbatimModuleSyntax",
+              // --- Completeness
+              "skipDefaultLibCheck",
+              "skipLibCheck"
+            ],
+            pathPattern: "^compilerOptions$"
+          },
+          {
+            order: { type: "asc" },
+            pathPattern: String.raw`^compilerOptions\.paths$`
+          }
+        ]
+      }
+    }
+  ];
+}
+function node() {
+  return [
+    nodePlugin.configs["flat/recommended"],
+    {
+      settings: {
+        node: {
+          version: ">=20.0.0"
+        }
+      },
+      rules: {
+        // --- Redundant with TypeScript module resolution.
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off",
+        "n/no-unpublished-import": "off",
+        // --- Enforce async functions over synchronous functions.
+        "n/no-sync": ["error", { allowAtRootLevel: !0 }],
+        // --- Enforce the use of ECMAScript features.
+        "n/no-unsupported-features/es-syntax": "error",
+        "n/no-unsupported-features/es-builtins": "error",
+        // --- Ignore experimental warnings.
+        "n/no-unsupported-features/node-builtins": "off",
+        // --- Prefer the use of global objects over built-in modules.
+        "n/prefer-global/buffer": "error",
+        "n/prefer-global/console": "error",
+        "n/prefer-global/process": "error",
+        "n/prefer-global/text-decoder": "error",
+        "n/prefer-global/text-encoder": "error",
+        "n/prefer-global/url": "error",
+        "n/prefer-global/url-search-params": "error",
+        // --- Prefer the use of the `node:` protocol for built-in modules.
+        "n/prefer-node-protocol": "error",
+        // --- Prefer the use of promises over callbacks.
+        "n/prefer-promises/fs": "error",
+        "n/prefer-promises/dns": "error"
+      }
+    },
+    {
+      files: [
+        "**/*.test.ts",
+        "**/*.spec.ts"
+      ],
+      rules: {
+        // --- Disable the no-sync rule for tests.
+        "n/no-sync": "off"
+      }
+    }
+  ];
+}
+function sonarjs() {
+  return [
+    pluginSonarjs.configs.recommended,
+    {
+      rules: {
+        // --- Increase the default threshold to 30.
+        "sonarjs/cognitive-complexity": ["error", 30],
+        // --- Increase the default threshold to 10.
+        "sonarjs/no-duplicate-string": ["error", { threshold: 10 }],
+        // --- Disable unnecessary rules.
+        "sonarjs/use-type-alias": "off",
+        "sonarjs/no-use-of-empty-return-value": "off",
+        "sonarjs/no-nested-functions": "off",
+        // --- Disable rules that are already covered by TypeScript.
+        "sonarjs/no-extra-arguments": "off",
+        "sonarjs/function-return-type": "off",
+        "sonarjs/no-misused-promises": "off",
+        "sonarjs/no-invariant-returns": "off",
+        "sonarjs/no-unused-expressions": "off",
+        "sonarjs/different-types-comparison": "off",
+        // --- Allow control characters in regex.
+        "sonarjs/sonar-no-control-regex": "off"
+      }
+    },
+    {
+      files: [
+        "**/*.test.ts",
+        "**/*.spec.ts"
+      ],
+      rules: {
+        // --- Disable unnecessary rules for test files.
+        "sonarjs/cognitive-complexity": "off",
+        "sonarjs/no-duplicate-string": "off",
+        "sonarjs/no-useless-constructor": "off",
+        "sonarjs/public-static-readonly": "off"
+      }
+    }
+  ];
+}
+function typescript(options) {
+  return [
+    javascript.configs.recommended,
+    // stylistic.configs['recommended-flat'],
+    {
+      languageOptions: {
+        // @ts-expect-error: ignore
+        parser: tslint.parser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          project: toArray(options.tsConfigPath ?? "./tsconfig.json"),
+          tsconfigRootDir: process.cwd()
+        }
+      },
+      plugins: {
+        "@typescript-eslint": tslint.plugin,
+        "@stylistic": stylistic,
+        perfectionist
+      },
+      files: [
+        "**/*.{ts,tsx,cts,mts}",
+        "**/*.{js,jsx,cjs,mjs}",
+        "**/*.vue"
+      ],
+      rules: {
+        /**
+         * Inherit all recommended rules from the `@eslint/js` plugin. This is the base
+         * configuration for JavaScript files.
+         */
+        ...getConfigRules(tslint.configs.recommendedTypeChecked),
+        ...getConfigRules(tslint.configs.stylisticTypeChecked),
+        // --- Enforce stroustrup brace style.
+        "brace-style": "off",
+        "@typescript-eslint/brace-style": "off",
+        "@stylistic/brace-style": ["error", "stroustrup", { allowSingleLine: !0 }],
+        // --- Enforce 2 spaces for indentation and disallow tabs.
+        "no-tabs": "off",
+        indent: "off",
+        "indent-binary-ops": "off",
+        "@typescript-eslint/no-tabs": "off",
+        "@typescript-eslint/indent": "off",
+        "@typescript-eslint/indent-binary-ops": "off",
+        "@stylistic/no-tabs": "error",
+        "@stylistic/indent": ["error", 2],
+        "@stylistic/indent-binary-ops": ["error", 2],
+        // --- No semicolons.
+        semi: "off",
+        "@typescript-eslint/semi": "off",
+        "@stylistic/semi": ["error", "never"],
+        // --- Consistent line breaks.
+        "eol-last": "off",
+        "no-multiple-empty-lines": "off",
+        "@stylistic/eol-last": ["error", "always"],
+        "@stylistic/no-multiple-empty-lines": ["error", { max: 1, maxBOF: 0, maxEOF: 0 }],
+        // --- Enforce dangling commas in multiline object literals.
+        "comma-dangle": "off",
+        "@typescript-eslint/comma-dangle": "off",
+        "@stylistic/comma-dangle": ["error", "always-multiline"],
+        // --- Enforce type interfaces over type aliases.
+        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        "@typescript-eslint/array-type": ["error", { default: "array-simple", readonly: "array-simple" }],
+        // --- Enforce declaration and usage from top to bottom.
+        "no-use-before-define": "off",
+        "@typescript-eslint/no-use-before-define": ["error", {
+          enums: !0,
+          classes: !1,
+          typedefs: !0,
+          variables: !0,
+          functions: !1,
+          ignoreTypeReferences: !0
+        }],
+        // --- Consistent spacing and line breaks between tokens.
+        "key-spacing": "off",
+        "comma-spacing": "off",
+        "block-spacing": "off",
+        "arrow-spacing": "off",
+        "spaced-comment": "off",
+        "no-multi-spaces": "off",
+        "space-before-blocks": "off",
+        "lines-around-comment": "off",
+        "object-curly-spacing": "off",
+        "array-bracket-spacing": "off",
+        "array-bracket-newline": "off",
+        "function-call-spacing": "off",
+        "generator-star-spacing": "off",
+        "template-curly-spacing": "off",
+        "object-property-newline ": "off",
+        "newline-per-chained-call": "off",
+        "computed-property-spacing": "off",
+        "lines-between-class-members": "off",
+        "@typescript-eslint/comma-spacing": "off",
+        "@typescript-eslint/object-curly-spacing": "off",
+        "@typescript-eslint/type-annotation-spacing": "off",
+        "@typescript-eslint/lines-around-comment": "off",
+        "@stylistic/key-spacing": ["error", { afterColon: !0, beforeColon: !1 }],
+        "@stylistic/comma-spacing": ["error", { after: !0, before: !1 }],
+        "@stylistic/arrow-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/type-generic-spacing": "error",
+        "@stylistic/type-named-tuple-spacing": "error",
+        "@stylistic/block-spacing": ["error", "always"],
+        "@stylistic/no-multi-spaces": "error",
+        "@stylistic/keyword-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/space-before-blocks": ["error", "always"],
+        "@stylistic/object-curly-spacing": ["error", "always"],
+        "@stylistic/array-bracket-spacing": ["error", "never"],
+        "@stylistic/array-bracket-newline": ["error", "consistent"],
+        "@stylistic/function-call-spacing": ["error", "never"],
+        "@stylistic/template-curly-spacing": ["error", "never"],
+        "@stylistic/member-delimiter-style": ["error", { multiline: { delimiter: "none" } }],
+        "@stylistic/object-property-newline": ["error", { allowAllPropertiesOnSameLine: !0 }],
+        "@stylistic/generator-star-spacing": ["error", { before: !0, after: !0 }],
+        "@stylistic/computed-property-spacing": ["error", "never"],
+        "@stylistic/multiline-ternary": ["error", "always-multiline"],
+        "@stylistic/lines-around-comment": ["error", {
+          beforeBlockComment: !0,
+          beforeLineComment: !0,
+          ignorePattern: String.raw`^(?! ?---|\*)`,
+          applyDefaultIgnorePatterns: !0,
+          afterHashbangComment: !0
+        }],
+        "@stylistic/spaced-comment": ["error", "always", {
+          block: { markers: ["!"], exceptions: ["*"], balanced: !0 },
+          line: { markers: ["/"], exceptions: ["/", "#"] }
+        }],
+        "@stylistic/lines-between-class-members": ["error", {
+          enforce: [{ blankLine: "always", prev: "method", next: "*" }]
+        }, {
+          exceptAfterSingleLine: !0
+        }],
+        "@stylistic/type-annotation-spacing": ["error", {
+          before: !0,
+          after: !0,
+          overrides: {
+            arrow: { before: !0, after: !0 },
+            colon: { before: !1, after: !0 },
+            variable: { before: !1, after: !0 },
+            property: { before: !1, after: !0 },
+            parameter: { before: !1, after: !0 },
+            returnType: { before: !1, after: !0 }
+          }
+        }],
+        // --- Enforce `@ts-expect-error` over `@ts-ignore`.
+        "@typescript-eslint/prefer-ts-expect-error": "error",
+        "@typescript-eslint/ban-ts-comment": ["error", {
+          "ts-check": !1,
+          "ts-expect-error": "allow-with-description",
+          "ts-ignore": !1,
+          "ts-nocheck": !1
+        }],
+        /**
+         * Disallow dangling expressions and promises. This rule aims to prevent
+         * dangling promises and expressions that are not assigned to a variable.
+         * This can lead to bugs and unexpected behavior in the codebase.
+         *
+         * @see https://eslint.org/docs/rules/no-void
+         * @see https://typescript-eslint.io/rules/no-floating-promises
+         */
+        "no-void": "off",
+        "no-unused-expressions": "off",
+        "@typescript-eslint/no-unused-expressions": "error",
+        "@typescript-eslint/no-floating-promises": ["error", {
+          ignoreVoid: !0,
+          ignoreIIFE: !0
+        }],
+        /**
+         * Sort imports alphabetically and group them without newlines. This rule
+         * aims to maintain consistency around the order of imports in JavaScript
+         * files. Helps reduce the visual noise in the codebase.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-type-imports
+         * @see https://eslint-plugin-perfectionist.azat.io/rules/sort-imports
+         */
+        "sort-imports": "off",
+        "@typescript-eslint/consistent-type-imports": ["error", {
+          disallowTypeAnnotations: !1,
+          prefer: "type-imports",
+          fixStyle: "separate-type-imports"
+        }],
+        "perfectionist/sort-exports": ["error", {
+          type: "alphabetical",
+          ignoreCase: !0
+        }],
+        "perfectionist/sort-named-imports": ["error", {
+          type: "alphabetical",
+          ignoreCase: !0
+        }],
+        "perfectionist/sort-imports": ["error", {
+          newlinesBetween: "never",
+          order: "asc",
+          ignoreCase: !0,
+          groups: [
+            "type",
+            "internal-type",
+            ["parent-type", "sibling-type", "index-type"],
+            ["builtin", "external"],
+            "internal",
+            ["parent", "sibling", "index"],
+            "object",
+            "unknown"
+          ]
+        }],
+        /**
+         * Sort types and union types alphabetically. This rule aims to maintain
+         * consistency around the order of types in TypeScript files. Helps reduce
+         * the visual noise in the codebase.
+         *
+         * @see https://perfectionist.dev/rules/sort-union-types
+         */
+        "@typescript-eslint/sort-type-constituents": "off",
+        "perfectionist/sort-intersection-types": ["error", {
+          type: "natural"
+        }],
+        "perfectionist/sort-union-types": ["error", {
+          type: "natural",
+          ignoreCase: !1
+        }],
+        /**
+         * Enforce no unused variables. Helps keep the codebase clean and reduces
+         * the chance of bugs from side-effects.
+         *
+         * @see https://typescript-eslint.io/rules/@typescript-eslint/no-unused-vars
+         */
+        "no-redeclare": "off",
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-redeclare": "error",
+        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+        //////////////////////////////////////////////////////////////////////////////////////////
+        "no-useless-constructor": "off",
+        "@typescript-eslint/ban-types": "off",
+        "@typescript-eslint/camelcase": "off",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/no-empty-function": "off",
+        "@typescript-eslint/no-empty-interface": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/no-parameter-properties": "off",
+        "array-callback-return": "error",
+        "arrow-body-style": ["error", "as-needed"],
+        "arrow-parens": ["error", "as-needed", { requireForBlockBody: !0 }],
+        "block-scoped-var": "error",
+        camelcase: "off",
+        "comma-style": ["error", "last"],
+        complexity: ["off", 11],
+        "consistent-return": "off",
+        curly: ["error", "multi-or-nest", "consistent"],
+        eqeqeq: ["error", "smart"],
+        "no-alert": "error",
+        "no-case-declarations": "error",
+        "no-cond-assign": ["error", "always"],
+        "no-confusing-arrow": "error",
+        "no-console": ["warn", { allow: ["warn", "error"] }],
+        "no-constant-condition": "error",
+        "no-debugger": "error",
+        "no-eval": "error",
+        "no-implied-eval": "error",
+        "no-multi-str": "error",
+        "no-param-reassign": "off",
+        "no-restricted-syntax": ["error", "DebuggerStatement", "LabeledStatement", "WithStatement"],
+        "no-return-assign": "off",
+        "no-return-await": "off",
+        "no-trailing-spaces": "error",
+        "no-useless-escape": "off",
+        "no-var": "error",
+        "no-with": "error",
+        "object-shorthand": ["error", "always", { avoidQuotes: !0, ignoreConstructors: !1 }],
+        "one-var-declaration-per-line": "error",
+        "operator-linebreak": ["error", "before"],
+        "prefer-arrow-callback": ["error", { allowNamedFunctions: !1, allowUnboundThis: !0 }],
+        "prefer-const": ["error", { destructuring: "any", ignoreReadBeforeAssign: !0 }],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "quote-props": ["error", "consistent-as-needed"],
+        quotes: ["error", "single"],
+        "require-await": "off",
+        "space-before-function-paren": ["error", "never"],
+        "vars-on-top": "error"
+      }
+    },
+    /**
+     * Ignore duplicate imports in declaration files as they are often used to re-export
+     * types from other packages into multiple namespaces. This is a common pattern
+     * in TypeScript declaration files.
+     */
+    {
+      files: ["*.d.ts"],
+      rules: {
+        "@typescript-eslint/no-use-before-define": "off",
+        "import/no-duplicates": "off"
+      }
+    },
+    /**
+     * Allow console statements in scripts and CLI files since they are not part of the
+     * library / production code and are useful for debugging, logging, and testing.
+     */
+    {
+      files: ["**/scripts/**/*", "cli.*"],
+      rules: {
+        "no-console": "off"
+      }
+    }
+  ];
+}
+function unicorn() {
+  return [
+    unicornPlugin.configs["flat/recommended"],
+    {
+      rules: {
+        // --- Allow any kind of import style.
+        "unicorn/import-style": "off",
+        // --- Improve regexes by making them shorter, consistent, and safer.
+        "unicorn/better-regex": "error",
+        // --- Use destructured variables over properties.
+        "unicorn/consistent-destructuring": "error",
+        // --- Enforce consistent function scoping except for arrow functions.
+        "unicorn/consistent-function-scoping": ["error", { checkArrowFunctions: !1 }],
+        // --- Disable switch-case fallthrough.
+        "unicorn/prefer-switch": "off",
+        // --- Enforce camelCase & PascalCase in filenames. Exepct non TS/JS files.
+        "unicorn/filename-case": ["error", {
+          multipleFileExtensions: !1,
+          cases: { camelCase: !0, pascalCase: !0 },
+          ignore: [/\.json$/, /\.md$/, /\.yml$/, /\.yaml$/]
+        }],
+        // --- Improve readability by using numeric separators.
+        "unicorn/numeric-separators-style": ["error", {
+          onlyIfContainsSeparator: !0
+        }],
+        // --- Enforce long variable names when they are meaningful.
+        "unicorn/prevent-abbreviations": ["error", {
+          allowList: {
+            args: !0,
+            dir: !0,
+            fn: !0,
+            i: !0,
+            j: !0,
+            k: !0,
+            ref: !0,
+            Ref: !0,
+            props: !0,
+            Props: !0,
+            v: !0,
+            x: !0,
+            y: !0,
+            z: !0
+          }
+        }]
+      }
+    },
+    {
+      files: [
+        "**/*.test.ts",
+        "**/*.spec.ts"
+      ],
+      rules: {
+        // --- Disable unnecessary rules for test files.
+        "unicorn/no-null": "off",
+        "unicorn/no-useless-undefined": "off",
+        "unicorn/no-static-only-class": "off"
+      }
+    }
+  ];
+}
+function vitest() {
+  return [
+    vitestPlugin.configs.recommended,
+    {
+      rules: {
+        // --- Add the `expectTypeOf` function to the list of assert functions.
+        "vitest/expect-expect": ["error", {
+          assertFunctionNames: ["expect", "expectTypeOf"]
+        }],
+        // --- Enforce a single top-level describe block.
+        "vitest/require-top-level-describe": ["error", { maxNumberOfTopLevelDescribes: 1 }],
+        // --- Enforce 'should' as the prefix for test titles.
+        "vitest/valid-title": ["error", {
+          ignoreTypeOfDescribeName: !0,
+          mustMatch: { test: ["^should"] }
+        }],
+        // --- Prefer strict equality checks.
+        "vitest/prefer-to-be-truthy": "off",
+        "vitest/prefer-to-be-falsy": "off",
+        /// --- Loosen the rules for test files.
+        "vitest/no-hooks": "off",
+        "vitest/require-hook": "off",
+        "vitest/no-conditional-in-test": "off",
+        "vitest/no-conditional-tests": "off",
+        "vitest/prefer-expect-assertions": "off",
+        "vitest/padding-around-all": "off",
+        "vitest/padding-around-expect-groups": "off"
+      }
+    }
+  ];
+}
+function vue(options) {
+  const TYPESCRIPT_CONFIG = typescript(options).at(1);
+  return [
+    ...vuePlugin.configs["flat/recommended"],
+    {
+      plugins: {
+        vue: vuePlugin,
+        ...TYPESCRIPT_CONFIG.plugins
+      },
+      languageOptions: {
+        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: vueParser,
+        parserOptions: {
+          parser: tslint.parser,
+          extraFileExtensions: [".vue"],
+          ...TYPESCRIPT_CONFIG.languageOptions.parserOptions
+        }
+      },
+      processor: mergeProcessors([
+        vuePlugin.processors.vue,
+        vueProcessorBlocks()
+      ]),
+      files: [
+        "**/*.vue",
+        "**/*.ts"
+      ],
+      rules: {
+        "vue/return-in-computed-property": "off",
+        // --- Allow multiple component definitions in a single file.
+        "vue/one-component-per-file": "off",
+        // --- Enforce Component API style.
+        "vue/prefer-define-options": "error",
+        "vue/component-api-style": ["error", ["script-setup", "composition"]],
+        // --- Enforce PascalCase components and allow reserved and single-word names.
+        "vue/multi-word-component-names": "off",
+        "vue/no-reserved-component-names": "off",
+        "vue/component-name-in-template-casing": ["error", "PascalCase", {
+          ignores: [String.raw`/\./`],
+          registeredComponentsOnly: !1
+        }],
+        // --- Consistent spacing around HTML comments.
+        "vue/html-comment-indent": ["error", 2],
+        "vue/multiline-html-element-content-newline": ["error", {
+          allowEmptyLines: !0,
+          ignores: [],
+          ignoreWhenEmpty: !0
+        }],
+        "vue/html-comment-content-spacing": ["error", "always"],
+        "vue/html-comment-content-newline": ["error", {
+          multiline: "always",
+          singleline: "never"
+        }],
+        // --- Consistent block order in Vue components.
+        "vue/block-order": ["error", { order: ["script", "template", "style", "i18n"] }],
+        // --- Consistent spacing in and around the block.
+        "vue/block-spacing": ["error", "always"],
+        "vue/padding-line-between-blocks": ["error", "always"],
+        "vue/padding-line-between-tags": ["error", [
+          { blankLine: "consistent", next: "*", prev: "*" },
+          { blankLine: "always", next: "*", prev: "comment" }
+        ]],
+        /**
+         * Enforce consistent spacing and newlines in the template. This rule helps
+         * to maintain consistency and readability by enforcing a predictable
+         *
+         * @see https://eslint.vuejs.org/rules/html-indent.html
+         * @see https://eslint.vuejs.org/rules/max-attributes-per-line.html
+         * @see https://eslint.vuejs.org/rules/html-closing-bracket-newline.html
+         */
+        "vue/html-indent": ["error", 2, {
+          alignAttributesVertically: !0,
+          attribute: 1,
+          baseIndent: 1,
+          closeBracket: 0,
+          ignores: []
+        }],
+        // 'vue/func-call-spacing': ['off', 'never'],
+        "vue/key-spacing": ["error", { afterColon: !0, beforeColon: !1 }],
+        "vue/keyword-spacing": ["error", { after: !0, before: !0 }],
+        "vue/max-attributes-per-line": ["error", {
+          multiline: { max: 1 },
+          singleline: { max: 5 }
+        }],
+        /**
+         * Allow single-word component names. This rule is disabled because we use
+         * pascal-casing to distinguish between components and HTML elements.
+         *
+         * @see https://eslint.vuejs.org/rules/multi-word-component-names.html
+         */
+        /**
+         * Reports the destructuring or member expression of props passed to setup
+         * causing the value to lose reactivity. This rule helps to avoid common
+         * pitfalls when using the Composition API.
+         *
+         * @see https://eslint.vuejs.org/rules/no-setup-props-reactivity-loss.html
+         */
+        "vue/no-setup-props-reactivity-loss": "error",
+        /**
+         * Disallow v-if in v-for. This rule helps to avoid common pitfalls when
+         * using v-if and v-for together in the same element.
+         *
+         * @see https://eslint.vuejs.org/rules/no-use-v-if-with-v-for.html
+         */
+        "vue/no-use-v-if-with-v-for": "error",
+        /**
+         * Enforce the declaration of emits in the setup function and warn on unused
+         * emits declarations. This rule helps reduce the risk stale code.
+         *
+         * @see https://eslint.vuejs.org/rules/require-explicit-emits.html
+         * @see https://eslint.vuejs.org/rules/no-unused-emit-declarations.html
+         */
+        "vue/require-explicit-emits": "error",
+        /**
+         * Enforce the `@` shorthand over `v-on:` and only allow inline callbacks.
+         * This rule helps to maintain consistency and readability by enforcing a
+         * predictable order of the event handlers in the component.
+         *
+         * @see https://eslint.vuejs.org/rules/v-on-style.html
+         * @see https://eslint.vuejs.org/rules/v-on-handler-style.html
+         */
+        "vue/v-on-style": ["error", "shorthand"],
+        "vue/v-on-handler-style": ["error", "inline-function"],
+        /**
+         * Sort the vue attributes in a consistent order. This rule helps to maintain
+         * consistency and readability by enforcing a predictable order of the
+         * attributes in the component.
+         *
+         * @see https://eslint.vuejs.org/rules/attributes-order.html
+         */
+        "vue/attributes-order": ["error", {
+          order: [
+            "DEFINITION",
+            "LIST_RENDERING",
+            "CONDITIONALS",
+            "RENDER_MODIFIERS",
+            "GLOBAL",
+            ["UNIQUE", "SLOT"],
+            "TWO_WAY_BINDING",
+            "OTHER_DIRECTIVES",
+            "OTHER_ATTR",
+            "EVENTS",
+            "CONTENT"
+          ],
+          alphabetical: !1
+        }],
+        /**
+         * Enforce consistent spacing around attribute assignments. This ensures that
+         * the code is easier to read and maintain.
+         *
+         * @see https://eslint.vuejs.org/rules/no-spaces-around-equal-signs-in-attribute.html
+         */
+        "vue/no-spaces-around-equal-signs-in-attribute": "error",
+        "vue/no-multi-spaces": "error",
+        /**
+         * Enforce the use of the `ts` lang attribute in the script block. This rule
+         * explicitly dissallows the use of the `js` lang attribute in the script.
+         */
+        "vue/block-lang": ["error", {
+          script: { lang: "ts" }
+        }],
+        "vue/no-sparse-arrays": "error",
+        "vue/no-unused-emit-declarations": "error",
+        "vue/no-use-v-else-with-v-for": "error",
+        "vue/no-useless-v-bind": "error",
+        "vue/no-v-html": "off",
+        "vue/no-v-text-v-html-on-component": "error",
+        "vue/object-curly-newline": ["error", { consistent: !0, multiline: !0 }],
+        "vue/object-curly-spacing": ["error", "always"],
+        "vue/object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidQuotes: !0,
+            ignoreConstructors: !1
+          }
+        ],
+        "vue/operator-linebreak": ["error", "before"],
+        "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",
+        // reactivity transform
+        "vue/block-tag-newline": ["error", {
+          multiline: "always",
+          singleline: "always"
+        }],
+        // extensions
+        "vue/array-bracket-spacing": ["error", "never"],
+        "vue/arrow-spacing": ["error", { after: !0, before: !0 }],
+        "vue/brace-style": ["error", "stroustrup", { allowSingleLine: !0 }],
+        "vue/comma-dangle": ["error", "always-multiline"],
+        "vue/comma-spacing": ["error", { after: !0, before: !1 }],
+        "vue/comma-style": ["error", "last"],
+        "vue/component-options-name-casing": ["error", "PascalCase"],
+        "vue/custom-event-name-casing": ["error", "camelCase"],
+        "vue/define-macros-order": ["error", {
+          order: ["defineProps", "defineEmits"]
+        }],
+        "vue/dot-location": ["error", "property"],
+        "vue/dot-notation": ["error", { allowKeywords: !0 }],
+        "vue/eqeqeq": ["error", "smart"],
+        "vue/first-attribute-linebreak": ["error", {
+          multiline: "below",
+          singleline: "beside"
+        }],
+        "vue/html-closing-bracket-newline": ["error", {
+          multiline: "never",
+          selfClosingTag: {
+            multiline: "always",
+            singleline: "never"
+          },
+          singleline: "never"
+        }],
+        "vue/no-constant-condition": "warn",
+        "vue/no-empty-pattern": "error",
+        "vue/no-extra-parens": ["error", "functions"],
+        "vue/no-irregular-whitespace": "error",
+        "vue/no-loss-of-precision": "error",
+        "vue/no-restricted-syntax": [
+          "error",
+          "DebuggerStatement",
+          "LabeledStatement",
+          "WithStatement"
+        ],
+        "vue/no-restricted-v-bind": ["error", "/^v-/"],
+        "vue/require-prop-types": "off",
+        "vue/space-in-parens": ["error", "never"],
+        "vue/space-infix-ops": "error",
+        "vue/space-unary-ops": ["error", { nonwords: !1, words: !0 }],
+        "vue/template-curly-spacing": "error"
+      }
+    },
+    // --- Disable some TypeScript rules that may conflict with the Vue SFC parser.
+    {
+      files: [
+        "**/*.vue"
+      ],
+      rules: {
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/no-unsafe-argument": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-misused-promises": "off"
+      }
+    },
+    // --- Disable in test files.
+    {
+      files: [
+        "**/*.test.ts",
+        "**/*.spec.ts"
+      ],
+      rules: {
+        "vue/one-component-per-file": "off"
+      }
+    }
+  ];
+}
+function yml() {
+  return [
+    ...pluginYml.configs["flat/standard"],
+    ...pluginYml.configs["flat/recommended"],
+    {
+      rules: {
+        // --- Force single quotes.
+        "yml/quotes": ["error", {
+          avoidEscape: !0,
+          prefer: "single"
+        }],
+        // --- Remove trailing zeros in numbers.
+        "yml/no-trailing-zeros": "error",
+        // --- Prevent empty keys.
+        "yml/require-string-key": "error",
+        // --- Prevent empty values or weird newlines in mappings.
+        "yml/block-mapping-colon-indicator-newline": "error",
+        // --- No more than one empty line.
+        "yml/no-multiple-empty-lines": ["error", {
+          max: 1,
+          maxBOF: 0,
+          maxEOF: 0
+        }],
+        // --- Sort environemnt variables alphabetically.
+        "yml/sort-sequence-values": ["error", {
+          pathPattern: "^env$",
+          order: { type: "asc" }
+        }]
+      }
+    }
+  ];
+}
+function all(options = {}) {
+  return [
+    ...antfu(),
+    ...eslintComments(),
+    ...jsdoc(),
+    ...json(),
+    ...jsonPackage(),
+    ...jsonTsconfig(),
+    ...node(),
+    ...sonarjs(),
+    ...typescript(options),
+    ...unicorn(),
+    ...vitest(),
+    ...vue(options),
+    ...yml(),
+    {
+      ignores: [
+        "**/dist",
+        "**/bin",
+        "**/node_modules",
+        "**/.nuxt",
+        "**/.output",
+        "**/coverage",
+        "**/public",
+        "**/__wip__",
+        "**/__snapshots__",
+        "**/LICENSE*",
+        "**/CHANGELOG*",
+        "packages-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock"
+      ]
+    }
+  ];
+}
+export {
+  all,
+  antfu,
+  eslintComments,
+  jsdoc,
+  json,
+  jsonPackage,
+  jsonTsconfig,
+  typescript,
+  unicorn,
+  vitest,
+  vue
+};
+//# sourceMappingURL=configs.js.map