@unshared/eslint-config 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1358 @@
+"use strict";
+var vueParser = require("vue-eslint-parser"), tslint = require("typescript-eslint"), vuePlugin = require("eslint-plugin-vue"), vitestPlugin = require("eslint-plugin-vitest"), unicornPlugin = require("eslint-plugin-unicorn"), stylisticPlugin = require("@stylistic/eslint-plugin"), eslintrc = require("@eslint/eslintrc"), nodePlugin = require("eslint-plugin-n"), jsonc = require("eslint-plugin-jsonc"), pluginJsdoc = require("eslint-plugin-jsdoc"), javascriptPlugin = require("@eslint/js"), eslintCommentsPlugin = require("eslint-plugin-eslint-comments"), pluginAntfu = require("eslint-plugin-antfu");
+const VUE_RECOMMENDED_RULES = vuePlugin.configs?.["flat/recommended"].rules;
+function vue() {
+  return [
+    {
+      files: [
+        "**/*.vue"
+      ],
+      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: {
+          ecmaFeatures: { jsx: !1 },
+          ecmaVersion: "latest",
+          parser: tslint.parser,
+          sourceType: "module"
+        }
+      },
+      plugins: {
+        "@typescript-eslint": tslint.plugin,
+        vue: vuePlugin
+      },
+      rules: {
+        ...VUE_RECOMMENDED_RULES,
+        /**
+         * Enforces consistent usage of type imports. This rule will enforce the use
+         * of `type` imports to make it easier for the Vue SFC compiler to analyze
+         * the code and infer the dependency graph correctly.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-type-imports
+         * @see https://vuejs.github.io/vetur/guide/FAQ.html#why-does-vetur-show-cannot-find-module-xxx
+         */
+        "@typescript-eslint/consistent-type-imports": ["error", {
+          disallowTypeAnnotations: !1,
+          fixStyle: "inline-type-imports",
+          prefer: "type-imports"
+        }],
+        "no-undef": "off",
+        /**
+         * Disable the `no-unused-vars` rule because as it may trigger false positives
+         * when using the Composition API.
+         */
+        "no-unused-vars": "off",
+        /**
+         * Since we may use the auto-import feature of Nuxt / unplugin-autoimport,
+         * we may have access to global variables that are not known to ESLint.
+         *
+         * @see https://eslint.org/docs/latest/rules/no-undef
+         */
+        semi: "off",
+        // extensions
+        "vue/array-bracket-spacing": ["error", "never"],
+        "vue/arrow-spacing": ["error", { after: !0, before: !0 }],
+        "vue/block-lang": ["error", { script: { lang: "ts" } }],
+        /**
+         * Enforce the order of the top-level properties in the component. This rule
+         * helps to maintain consistency and readability by enforcing a predictable
+         * order of the top-level properties in the component.
+         *
+         * @see https://eslint.vuejs.org/rules/ordered-component-elements.html
+         */
+        "vue/block-order": ["error", {
+          order: [
+            "docs",
+            "script",
+            "template",
+            "style"
+          ]
+        }],
+        "vue/block-spacing": ["error", "always"],
+        // reactivity transform
+        "vue/block-tag-newline": ["error", {
+          multiline: "always",
+          singleline: "always"
+        }],
+        "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"],
+        /**
+         * Enforce use of the Composition API and TypeScript. This rule forbids the
+         * use of the Options API and JavaScript in Vue components for better
+         * consistency and maintainability.
+         *
+         * @see https://eslint.vuejs.org/rules/vue/prefer-define-options.html
+         */
+        "vue/component-api-style": ["error", ["script-setup"]],
+        /**
+         * Enforce the component name casing to be PascalCase. This rules helps identify
+         * and distinguish between components and HTML elements. It also helps to avoid
+         * conflicts with existing and future HTML elements.
+         *
+         * @see https://eslint.vuejs.org/rules/component-name-in-template-casing.html
+         */
+        "vue/component-name-in-template-casing": ["error", "PascalCase", {
+          ignores: ["/\\./"],
+          registeredComponentsOnly: !1
+        }],
+        "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/html-comment-content-newline": ["error", {
+          multiline: "always",
+          singleline: "never"
+        }],
+        /**
+         * Enforce consistent spacing between HTML comments and their content.
+         *
+         * @see https://eslint.vuejs.org/rules/html-comment-content-spacing.html
+         * @see https://eslint.vuejs.org/rules/html-comment-content-newline.html
+         */
+        "vue/html-comment-content-spacing": ["error", "always"],
+        /**
+         * Enforce consistent spacing between HTML / Component tags. This makes it
+         * easier to read and understand the structure of the component.
+         *
+         * @see https://eslint.vuejs.org/rules/padding-line-between-blocks.html
+         * @see https://eslint.vuejs.org/rules/padding-line-between-tags.html
+         */
+        "vue/html-comment-indent": ["error", 2],
+        /**
+         * 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
+         */
+        "vue/multi-word-component-names": "off",
+        "vue/multiline-html-element-content-newline": ["error", {
+          allowEmptyLines: !0,
+          ignores: [],
+          ignoreWhenEmpty: !0
+        }],
+        "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-/"],
+        /**
+         * 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",
+        "vue/no-sparse-arrays": "error",
+        "vue/no-unused-emit-declarations": "error",
+        "vue/no-use-v-else-with-v-for": "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",
+        "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/padding-line-between-blocks": ["error", "always"],
+        "vue/padding-line-between-tags": ["error", [
+          { blankLine: "consistent", next: "*", prev: "*" }
+        ]],
+        "vue/prefer-define-options": "error",
+        "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",
+        /**
+         * 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",
+        "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",
+        "vue/v-on-handler-style": ["error", "inline"],
+        /**
+         * 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"]
+      }
+    }
+  ];
+}
+function vitest() {
+  return [
+    {
+      files: [
+        "**/*.{ts,mts,cts,tsx,d.ts}",
+        "**/*.{js,mjs,cjs,jsx}"
+      ],
+      plugins: {
+        vitest: vitestPlugin
+      },
+      rules: {
+        /**
+         * Inject all configuration from eslint-plugin-vitest.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/tree/main?tab=readme-ov-file#rules
+         */
+        ...vitestPlugin.configs.all.rules,
+        /**
+         * This rule aims to enforce having at least one expectation
+         * in test body to ensure that the test is actually testing something.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+         */
+        "vitest/expect-expect": ["error", {
+          assertFunctionNames: [
+            "expect",
+            "expectTypeOf"
+          ]
+        }],
+        /**
+         * Disable the conditional test rule as it is prevent's us to use in-source
+         * testing when using the `if (import.meta.vitest)` condition. Also disable
+         * the rule that prevents the use of if-else statements in tests as we want
+         * to use it to test type predicates.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-in-test.md
+         */
+        "vitest/no-conditional-in-test": "off",
+        "vitest/no-conditional-tests": "off",
+        /**
+         * Allow hooks to be defined at the top-level of the test file.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/no-hooks.md
+         */
+        "vitest/no-hooks": "off",
+        /**
+         * Disable the rule that enforces the use of `expect.assertions` in tests.
+         * As much as this rule enforces a best-practice, it is not always necessary.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/prefer-expect-assertions.md
+         */
+        "vitest/prefer-expect-assertions": "off",
+        /**
+         * Some functions may have a single test case, and it is not necessary
+         * to wrap them in a describe block.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/require-top-level-describe.md
+         */
+        "vitest/require-top-level-describe": "off",
+        /**
+         * Enforce rule titles starts with 'should'. This is a convention
+         * to force the developer to write the test in a way that it reads
+         * like a sentence.
+         *
+         * @see https://github.com/veritem/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md
+         */
+        "vitest/valid-title": ["error", {
+          ignoreTypeOfDescribeName: !0,
+          mustMatch: {
+            test: ["^should"]
+          }
+        }]
+        // /**
+        //  * Allow runt
+        //  */
+        // 'vitest/require-hook': 'off',
+      }
+    }
+  ];
+}
+const UNICORN_RECOMMENDED_RULES = unicornPlugin.configs.recommended.rules;
+function unicorn() {
+  return [
+    {
+      plugins: {
+        unicorn: unicornPlugin
+      },
+      rules: {
+        ...UNICORN_RECOMMENDED_RULES,
+        /**
+         * Improve regexes by making them shorter, consistent, and safer. This rule
+         * aims to improve readability and consistency of regexes while also
+         * mitigating regex denial of service attacks by disallowing potentially
+         * catastrophic backtracking.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/better-regex.md
+         */
+        "unicorn/better-regex": "error",
+        /**
+         * Enforce the catch clause parameter name to be named `error`. This rule
+         * aims to enforce a consistent parameter name in catch clauses. The name
+         * `error` is the most commonly used name for the parameter that is passed
+         * to the catch clause.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/catch-error-name.md
+         */
+        "unicorn/catch-error-name": ["error", {
+          name: "error"
+        }],
+        "unicorn/consistent-function-scoping": "off",
+        "unicorn/error-message": "error",
+        "unicorn/escape-case": "error",
+        /**
+         * Enforce the use of camelCase or PascalCase when naming folders, files and
+         * variables. This rule aims to enforce a consistent naming convention for
+         * filenames, directory names, and variable names.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/filename-case.md
+         */
+        "unicorn/filename-case": ["error", {
+          cases: {
+            camelCase: !0,
+            pascalCase: !0
+          },
+          ignore: [
+            "^[A-Z]+(.md)?$"
+          ]
+        }],
+        /**
+         * Disable the recommended import style rules. We want to be able to use both
+         * named and default imports in our codebase.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/import-style.md
+         */
+        "unicorn/import-style": "off",
+        "unicorn/no-array-callback-reference": "off",
+        "unicorn/no-array-for-each": "off",
+        "unicorn/no-array-instanceof": "error",
+        "unicorn/no-new-buffer": "error",
+        "unicorn/no-static-only-class": "off",
+        /**
+         * Disallow unsafe regular expressions. Regular expressions can be unsafe
+         * when they are too complex and can cause catastrophic backtracking. This
+         * rule disallows regular expressions that can lead to catastrophic
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-unsafe-regex.md
+         */
+        "unicorn/no-unsafe-regex": "error",
+        "unicorn/number-literal-case": "error",
+        /**
+         * Enforces a convention of grouping digits using numeric separators.
+         * Long numbers can become really hard to read, so cutting it into groups
+         * of digits, separated with a _, is important to keep your code clear.
+         *
+         * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/numeric-separators-style.md
+         */
+        "unicorn/numeric-separators-style": ["error", {
+          onlyIfContainsSeparator: !0
+        }],
+        "unicorn/prefer-code-point": "off",
+        "unicorn/prefer-exponentiation-operator": "error",
+        "unicorn/prefer-includes": "error",
+        "unicorn/prefer-module": "off",
+        "unicorn/prefer-starts-ends-with": "error",
+        "unicorn/prefer-switch": "off",
+        "unicorn/prefer-text-content": "error",
+        "unicorn/prefer-type-error": "error",
+        "unicorn/prevent-abbreviations": ["error", {
+          allowList: {
+            args: !0,
+            dir: !0,
+            fn: !0,
+            i: !0,
+            j: !0,
+            k: !0,
+            props: !0,
+            Props: !0,
+            ref: !0,
+            v: !0,
+            x: !0,
+            y: !0,
+            z: !0
+          }
+        }],
+        "unicorn/throw-new-error": "error"
+      }
+    }
+  ];
+}
+const { recommendedTypeChecked, stylisticTypeChecked } = tslint.configs, TSLING_DEFAULT_RULES = [recommendedTypeChecked, stylisticTypeChecked].flat().map((x) => x.rules).reduce((accumulator, x) => ({ ...accumulator, ...x }), {});
+function typescript() {
+  return [
+    {
+      files: [
+        "**/*.ts",
+        "**/*.tsx"
+      ],
+      languageOptions: {
+        // @ts-expect-error: ignore
+        parser: tslint.parser,
+        parserOptions: {
+          project: [
+            "./tsconfig.json",
+            "./packages/*/tsconfig.json"
+          ]
+        }
+      },
+      plugins: {
+        "@typescript-eslint": tslint.plugin
+      },
+      rules: {
+        ...TSLING_DEFAULT_RULES,
+        /**
+         * Enforce consistent Array types. This rule aims to standardize the usage of
+         * `Array<T>` over `T[]`, and `ReadonlyArray<T>` over `readonly T[]`. Allows
+         * for reduced cognitive load when reading code that uses arrays. Exceptions
+         * are allowed for primitive or simple types.
+         *
+         * @see https://typescript-eslint.io/rules/array-type
+         */
+        "@typescript-eslint/array-type": ["error", {
+          default: "array-simple",
+          readonly: "array-simple"
+        }],
+        "@typescript-eslint/ban-ts-comment": ["error", {
+          "ts-check": !1,
+          "ts-expect-error": "allow-with-description",
+          "ts-ignore": !1,
+          "ts-nocheck": !1
+        }],
+        "@typescript-eslint/ban-ts-ignore": "off",
+        "@typescript-eslint/ban-types": "off",
+        "@typescript-eslint/brace-style": ["error", "stroustrup", {
+          allowSingleLine: !0
+        }],
+        "@typescript-eslint/camelcase": "off",
+        /**
+         * Enforce a trailing comma after the last element or property in a multiline
+         * list of properties or elements. This rule improves the clarity of diffs
+         * when an item is added or removed from an object or array.
+         *
+         * @see https://typescript-eslint.io/rules/comma-dangle
+         */
+        "@typescript-eslint/comma-dangle": ["error", "always-multiline"],
+        "@typescript-eslint/comma-spacing": ["error"],
+        /**
+         * Enforce `Record<K, T>` instead of `{ [K]: T }`. This rule aims to standardize
+         * the declaration of Record types and helps prevent bugs caused by typos.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-indexed-object-style
+         */
+        "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
+        /**
+         * Enforces `interface` usage over `type` usage. This allows for better consistency
+         * and identification of objects that can be augmented while favoring separation
+         * between interfaces describing objects and types describing primitives and/or unions.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-type-definitions
+         */
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        /**
+         * Enforces consistent usage of type imports. This rule will disallow the use of
+         * `import type` or `import { type }` to reduce the cognitive load of reasoning
+         * about imports. Typically, the bundler will know which imports are types and
+         * strip them out.
+         *
+         * @see https://typescript-eslint.io/rules/consistent-type-imports
+         */
+        "@typescript-eslint/consistent-type-imports": ["error", {
+          disallowTypeAnnotations: !1,
+          prefer: "no-type-imports"
+        }],
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        /**
+         * Enforce an indent of 2 spaces. Aims to reduce visual noise and maintain
+         * readability of code when viewed on GitHub or GitLab.
+         *
+         * @see https://typescript-eslint.io/rules/indent
+         */
+        "@typescript-eslint/indent": ["error", 2],
+        /**
+         * Enforce no comma/semi-columns in interfaces. This rule aims to maintain
+         * consistency around the use or omission of trailing semicolons. Helps
+         * reduce the visual noise in the codebase. Also helps to prevent errors
+         * when refactoring and adding new lines.
+         *
+         * @see https://typescript-eslint.io/rules/member-delimiter-style
+         */
+        "@typescript-eslint/member-delimiter-style": ["error", {
+          multiline: { delimiter: "none" }
+        }],
+        "@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",
+        "@typescript-eslint/no-redeclare": "error",
+        "@typescript-eslint/no-unused-expressions": "error",
+        "@typescript-eslint/no-unused-vars": ["error", {
+          argsIgnorePattern: "^_"
+        }],
+        "@typescript-eslint/no-use-before-define": ["error", {
+          classes: !1,
+          functions: !1,
+          variables: !0
+        }],
+        /**
+         * Enforce consistent spacing inside braces. This rule aims to reduce the
+         * cognitive load of reasoning about code by enforcing a consistent style.
+         *
+         * @see https://typescript-eslint.io/rules/object-curly-spacing
+         */
+        "@typescript-eslint/object-curly-spacing": ["error", "always"],
+        /**
+         * Enforce the use of `@ts-expect-error` over `@ts-ignore` to silence TypeScript
+         * errors. This rule aims to ensure that TypeScript errors are never silenced
+         * without explanation or justification. When an error is fixed, the
+         * `@ts-expect-error` forces the developer to remove the comment.
+         *
+         * @see https://typescript-eslint.io/rules/prefer-ts-expect-error
+         * @see https://typescript-eslint.io/rules/ban-ts-comment
+         */
+        "@typescript-eslint/prefer-ts-expect-error": "error",
+        "@typescript-eslint/semi": ["error", "never"],
+        /**
+         * Disable this rule as it may conflict with the `perfectionist/sort-imports` rule.
+         *
+         * @see https://typescript-eslint.io/rules/sort-type-constituents
+         */
+        "@typescript-eslint/sort-type-constituents": "off",
+        /**
+         * Enforce spacing around the `:` in type annotations. This rule aims to
+         * maintain consistency and reduce visual noise in the codebase.
+         *
+         * @see https://typescript-eslint.io/rules/type-annotation-spacing
+         */
+        "@typescript-eslint/type-annotation-spacing": ["error", {}],
+        /**
+         * Age-old debate over how to style braces. This rule aims to reduce the
+         * cognitive load of reasoning about code by enforcing a consistent style.
+         *
+         * @see https://typescript-eslint.io/rules/brace-style
+         */
+        "brace-style": "off",
+        "comma-dangle": "off",
+        /**
+         * Enforce standard comma-spacing. Normalizes the codebase and reduces
+         * cognitive load when reasoning about code.
+         *
+         * @see https://typescript-eslint.io/rules/comma-spacing
+         */
+        "comma-spacing": "off",
+        "import/named": "off",
+        indent: "off",
+        /**
+         * In JavaScript, it’s possible to redeclare the same variable name using var.
+         * This can lead to confusion as to where the variable is actually declared and initialized.
+         *
+         * @see https://typescript-eslint.io/rules/no-redeclare
+         */
+        "no-redeclare": "off",
+        /**
+         * Enforce no unused expressions. This rule aims to prevent dead code and
+         * reduce the likelihood of bugs.
+         *
+         * @see https://typescript-eslint.io/rules/no-unused-expressions
+         */
+        "no-unused-expressions": "off",
+        /**
+         * 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-unused-vars": "off",
+        /**
+         * Enforce sequential declarations in the same block. This rule aims to
+         * enforce a top to bottom ordering of variable and type declarations.
+         * This reduces the likelihood of a developer skipping over a declaration
+         * when modifying code.
+         *
+         * @see https://typescript-eslint.io/rules/no-use-before-define
+         */
+        "no-use-before-define": "off",
+        "no-useless-constructor": "off",
+        "object-curly-spacing": "off",
+        /**
+         * Enforce no semi-colons. This rule aims to maintain consistency around the
+         * use or omission of trailing semicolons. Helps reduce the visual noise in
+         * the codebase. Also helps to prevent errors when refactoring and adding
+         * new lines.
+         *
+         * @see https://typescript-eslint.io/rules/semi
+         */
+        semi: "off"
+      }
+    },
+    /**
+     * 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 stylistic() {
+  return [
+    {
+      plugins: {
+        "@stylistic": stylisticPlugin
+      },
+      rules: {
+        /**
+         * Enforce a line before any comment. This makes the code more readable and
+         * separates the comments from the code.
+         *
+         * @see https://eslint.style/rules/default/lines-around-comment
+         */
+        "@stylistic/lines-around-comment": ["error", {
+          allowArrayEnd: !0,
+          allowBlockEnd: !0,
+          allowBlockStart: !0,
+          allowObjectEnd: !0,
+          allowTypeStart: !0,
+          beforeBlockComment: !0,
+          beforeLineComment: !0,
+          ignorePattern: "^\\*"
+        }]
+      }
+    }
+  ];
+}
+function sonarjs() {
+  return new eslintrc.FlatCompat().config({
+    extends: [
+      "plugin:sonarjs/recommended"
+    ],
+    plugins: [
+      "sonarjs"
+    ],
+    rules: {
+      /**
+       * Cognitive Complexity is a measure of how hard the control flow of a function
+       * is to understand. Functions with high Cognitive Complexity will be difficult
+       * to maintain.
+       *
+       * @see https://github.com/SonarSource/eslint-plugin-sonarjs/blob/master/docs/rules/cognitive-complexity.md
+       */
+      "sonarjs/cognitive-complexity": ["error", 30],
+      /**
+       * Duplicated string literals make the process of refactoring error-prone,
+       * since you must be sure to update all occurrences. On the other hand,
+       * constants can be referenced from many places, but only need to be
+       * updated in a single place.
+       *
+       * @see https://github.com/SonarSource/eslint-plugin-sonarjs/blob/master/docs/rules/no-duplicate-string.md
+       */
+      "sonarjs/no-duplicate-string": ["error", {
+        threshold: 10
+      }],
+      "sonarjs/no-empty-collection": "off",
+      "sonarjs/no-extra-arguments": "off",
+      "sonarjs/no-gratuitous-expressions": "off",
+      /**
+       * Those rules are crashing ESLint at startup, so they are disabled for now.
+       */
+      "sonarjs/no-one-iteration-loop": "off",
+      "sonarjs/no-redundant-jump": "off",
+      "sonarjs/no-unused-collection": "off",
+      "sonarjs/no-use-of-empty-return-value": "off"
+    }
+  });
+}
+function perfectionist() {
+  return new eslintrc.FlatCompat().config({
+    extends: [
+      "plugin:perfectionist/recommended-natural"
+    ],
+    plugins: [
+      "perfectionist"
+    ],
+    rules: {
+      /**
+       * 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://eslint-plugin-perfectionist.azat.io/rules/sort-imports
+       */
+      "perfectionist/sort-imports": ["error", {
+        "newlines-between": "never",
+        order: "desc"
+      }],
+      /**
+       * Sort objects alphabetically. This rule aims to maintain consistency around
+       * the order of object properties in JavaScript files. Helps reduce the visual
+       * noise in the codebase.
+       *
+       * @see https://eslint-plugin-perfectionist.azat.io/rules/sort-objects
+       */
+      "perfectionist/sort-objects": ["error", {
+        "partition-by-comment": "--- **"
+      }]
+    }
+  });
+}
+function node() {
+  return [
+    {
+      plugins: {
+        n: nodePlugin
+      },
+      rules: {
+        ...nodePlugin.configs.recommended.rules,
+        /**
+         * Disallow the use of extraneous imports. This rule helps prevent the
+         * use of third-party modules that are not listed in the project's
+         * dependencies.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-extraneous-import.md
+         */
+        "n/no-extraneous-import": "error",
+        /**
+         * Disable the no-missing-import as module resolution is already checked
+         * by other tools and IDEs extensively. This rule is redundant.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-missing-import.md
+         */
+        "n/no-missing-import": "off",
+        "n/no-missing-require": "off",
+        "n/no-unsupported-features/es-builtins": "error",
+        /**
+         * Allow the use of features up to Node.js version 20. This will allow
+         * the use of newer ECMAScript features and Node.js APIs.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules
+         */
+        "n/no-unsupported-features/es-syntax": "error",
+        "n/no-unsupported-features/node-builtins": "error",
+        /**
+         * Prepend the `node:` prefix to all Node.js core modules. This helps
+         * identify the module as a Node.js core module and not a third-party
+         * module.
+         *
+         * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-node-protocol.md
+         */
+        "n/prefer-node-protocol": "error"
+      },
+      settings: {
+        node: {
+          version: ">=20.0.0"
+        }
+      }
+    }
+  ];
+}
+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: "^compilerOptions\\.paths$"
+          }
+        ]
+      }
+    }
+  ];
+}
+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 configJson() {
+  return [
+    ...jsonc.configs["flat/recommended-with-json"],
+    {
+      files: [
+        "**/*.json",
+        "**/*.json5"
+      ],
+      rules: {
+        /**
+         * Automatically apply jsonc rules similar to your configured ESLint core rules to JSON.
+         *
+         * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/auto.html
+         */
+        "jsonc/auto": "error"
+      }
+    }
+  ];
+}
+function jsdoc() {
+  return [
+    pluginJsdoc.configs["flat/recommended-typescript-flavor-error"],
+    {
+      files: [
+        "**/*.js",
+        "**/*.ts",
+        "**/*.tsx"
+      ],
+      rules: {
+        /**
+         * Enforce a consistent padding of the block description.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/HEAD/docs/rules/check-alignment.md#readme
+         */
+        "jsdoc/check-alignment": "error",
+        /**
+         * Normalize the indentation in the JSdoc comment to improve readability.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-indentation.md#readme
+         */
+        "jsdoc/check-indentation": "error",
+        /**
+         * Enforce a strict set of tags for the JSDoc comment. This rule also includes
+         * some custom tags that are used in our projects.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/.README/rules/check-tag-names.md
+         */
+        "jsdoc/check-tag-names": ["error", {
+          definedTags: [
+            "category"
+          ]
+        }],
+        /**
+         * Checks for multi-line-style comments which fail to meet the criteria of a jsdoc block,
+         * namely that it should begin with two and only two asterisks.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-bad-blocks.md#readme
+         */
+        "jsdoc/no-bad-blocks": "error",
+        /**
+         * It is common practice to prefix a hyphen to parameters in JSDoc. But this
+         * is sometimes forgotten and has no real purpose. This rule aims to enforce
+         * that no hyphen is used.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-hyphen-before-param-description#readme
+         */
+        "jsdoc/require-hyphen-before-param-description": ["error", "never"],
+        "jsdoc/require-jsdoc": "off",
+        "jsdoc/require-param-type": "off",
+        /**
+         * Since we are using TypeScript, we don't need to enforce types in JSDoc.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/.README/rules/require-return-type.md
+         */
+        "jsdoc/require-returns-type": "off",
+        /**
+         * Enforce a new-line between the JSDoc summary and tags. Aims to improve
+         * readability by separating the summary and tags.
+         *
+         * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/tag-lines.md#readme
+         */
+        "jsdoc/tag-lines": ["error", "any", { startLines: 1 }]
+      }
+    }
+  ];
+}
+function javascript() {
+  return [
+    {
+      rules: {
+        /**
+         * Inherit all recommended rules from the `@eslint/js` plugin. This is the base
+         * configuration for JavaScript files.
+         */
+        ...javascriptPlugin.configs.recommended.rules,
+        "array-bracket-spacing": ["error", "never"],
+        "array-callback-return": "error",
+        "arrow-body-style": ["error", "as-needed"],
+        "arrow-parens": ["error", "as-needed", { requireForBlockBody: !0 }],
+        "block-scoped-var": "error",
+        "block-spacing": ["error", "always"],
+        "brace-style": ["error", "stroustrup", { allowSingleLine: !0 }],
+        camelcase: "off",
+        "comma-dangle": ["error", "always-multiline"],
+        "comma-spacing": ["error", { after: !0, before: !1 }],
+        "comma-style": ["error", "last"],
+        complexity: ["off", 11],
+        "consistent-return": "off",
+        curly: ["error", "multi-or-nest", "consistent"],
+        "eol-last": "error",
+        eqeqeq: ["error", "smart"],
+        "func-call-spacing": ["off", "never"],
+        "generator-star-spacing": "off",
+        indent: ["error", 2, { outerIIFEBody: 1, SwitchCase: 1, VariableDeclarator: 1 }],
+        "key-spacing": ["error", { afterColon: !0, beforeColon: !1 }],
+        "n/no-callback-literal": "off",
+        "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-spaces": "error",
+        "no-multi-str": "error",
+        /**
+         * Enforce a consistent linebreak style. Reduces merge conflicts and makes the code
+         * more consistent between different iterations of the same file.
+         *
+         * @see https://eslint.org/docs/rules/linebreak-style
+         */
+        "no-multiple-empty-lines": ["error", {
+          max: 1,
+          maxBOF: 0,
+          maxEOF: 1
+        }],
+        "no-param-reassign": "off",
+        "no-restricted-syntax": ["error", "DebuggerStatement", "LabeledStatement", "WithStatement"],
+        "no-return-assign": "off",
+        "no-return-await": "off",
+        "no-trailing-spaces": "error",
+        "no-unused-vars": "warn",
+        "no-use-before-define": ["error", { classes: !1, functions: !1, variables: !0 }],
+        "no-useless-escape": "off",
+        "no-var": "error",
+        /**
+         * Allow `void` operator. It's useful to discard the result of an expression, especially
+         * when calling asynchronous functions that return a promise.
+         *
+         * @see https://eslint.org/docs/rules/no-void
+         */
+        "no-void": "off",
+        "no-with": "error",
+        "object-curly-spacing": ["error", "always"],
+        "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",
+        semi: ["error", "never"],
+        "space-before-function-paren": ["error", "never"],
+        "spaced-comment": ["error", "always", {
+          block: {
+            balanced: !0,
+            exceptions: ["*"],
+            markers: ["!"]
+          },
+          line: {
+            exceptions: ["/", "#"],
+            markers: ["/"]
+          }
+        }],
+        "template-curly-spacing": "error",
+        "vars-on-top": "error"
+      }
+    }
+  ];
+}
+function eslintComments() {
+  return [
+    {
+      plugins: {
+        "eslint-comments": eslintCommentsPlugin
+      },
+      rules: {
+        /**
+         * Allow multiple rules directive in a single comment. This
+         * reduces the number of comments in the code.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/disable-enable-pair
+         */
+        "eslint-comments/disable-enable-pair": "off",
+        /**
+         * `eslint-enable` directive-comments can enable rules which are disabled by different
+         * eslint-disable directive-comments. It can enable a rule unintentionally. This rule
+         * will report such cases.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-aggregating-enable
+         */
+        "eslint-comments/no-aggregating-enable": "error",
+        /**
+         * Disallow duplicate eslint-disable comments. This rule will report when there are
+         * multiple eslint-disable comments for the same rule, either in the same line or enabled
+         * by different eslint-disable comments.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-duplicate-disable
+         */
+        "eslint-comments/no-duplicate-disable": "error",
+        /**
+         * Disallow eslint-disable comments without rule names. This ensures that we cannot
+         * disable all rules in a file using eslint-disable comment.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-unlimited-disable
+         */
+        "eslint-comments/no-unlimited-disable": "error",
+        /**
+         * Errors when an eslint-disable comment has no effect. This is useful
+         * to prevent unnecessary comments in the code.
+         *
+         * @see https://mysticatea.github.io/eslint-plugin-eslint-comments/rules/no-unused-disable
+         */
+        "eslint-comments/no-unused-disable": "error"
+      }
+    }
+  ];
+}
+function antfu() {
+  return [
+    {
+      plugins: {
+        antfu: pluginAntfu
+      },
+      rules: {
+        "antfu/consistent-list-newline": "error",
+        /**
+         * Auto-fix import duplication. The TypeScript compiler already detects and removes
+         * duplicate imports, but this rule can be used to fix the issue automatically in the editor.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/import-dedupe.md
+         */
+        "antfu/import-dedupe": "error",
+        /**
+         * Enforce top-level function to be declared using function instead of arrow function. This
+         * rule helps when you want to add additional overload signatures to a function without
+         * having to transform the arrow function into a function declaration manually.
+         *
+         * On top of that, it mitigates the risk of accidentally using the `this` instance from
+         * an outer scope.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/top-level-function.md
+         */
+        "antfu/top-level-function": "error",
+        /**
+         * Enforce consistent line breaks inside braces of object/array/named imports/exports and
+         * function parameters. Reduces the cognitive load of reasoning about code style.
+         *
+         * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-list-newline.md
+         */
+        "object-curly-newline": "off"
+      }
+    }
+  ];
+}
+function all() {
+  return [
+    ...antfu(),
+    ...eslintComments(),
+    ...javascript(),
+    ...jsdoc(),
+    ...configJson(),
+    ...jsonPackage(),
+    ...jsonTsconfig(),
+    ...node(),
+    ...perfectionist(),
+    ...sonarjs(),
+    ...stylistic(),
+    ...typescript(),
+    ...unicorn(),
+    ...vitest(),
+    ...vue(),
+    // ...promise(),
+    // ...markdown(),
+    {
+      ignores: [
+        "**/dist",
+        "**/bin",
+        "**/node_modules",
+        "**/.nuxt",
+        "**/output",
+        "**/coverage",
+        "**/public",
+        "**/__wip__",
+        "**/__snapshots__",
+        "**/LICENSE*",
+        "**/CHANGELOG*",
+        "packages-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock"
+      ]
+    }
+  ];
+}
+var index = all();
+module.exports = index;
+//# sourceMappingURL=index.cjs.map