@tb-dev/eslint-config 1.4.8 → 1.4.10

package/dist/index.mjs

@@ -1,890 +0,0 @@
-import eslintConfigPrettier from 'eslint-config-prettier';
-import globals from 'globals';
-import process from 'node:process';
-
-var Glob;
-(function (Glob) {
-    Glob["ALL"] = "**/*.?([cm])[jt]s?(x)";
-    Glob["JAVASCRIPT"] = "**/*.?([cm])js?(x)";
-    Glob["TYPESCRIPT"] = "**/*.?([cm])ts?(x)";
-    Glob["VUE"] = "**/*.vue";
-})(Glob || (Glob = {}));
-var GlobIgnore;
-(function (GlobIgnore) {
-    GlobIgnore["CACHE"] = "**/cache";
-    GlobIgnore["DIST"] = "**/dist";
-    GlobIgnore["LOG"] = "**/log?(s)";
-    GlobIgnore["NODE_MODULES"] = "**/node_modules";
-    GlobIgnore["OUT"] = "**/out";
-    GlobIgnore["TEMP"] = "**/?(.)temp";
-})(GlobIgnore || (GlobIgnore = {}));
-
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-async function interopDefault(promise) {
-    const result = await promise;
-    return result.default ?? result;
-}
-function getIgnores() {
-    return Object.values(GlobIgnore);
-}
-
-/**
- * @see https://eslint.org/docs/latest/rules/
- */
-function javascript(options) {
-    const { overrides } = options;
-    const files = [Glob.ALL];
-    if (options.vue)
-        files.push(Glob.VUE);
-    return {
-        files,
-        languageOptions: {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            globals: {
-                ...globals.browser,
-                ...globals.es2021,
-                ...globals.node,
-                document: 'readonly',
-                window: 'readonly'
-            }
-        },
-        rules: {
-            'accessor-pairs': ['error', { enforceForClassMembers: true, setWithoutGet: true }],
-            'array-callback-return': [
-                'error',
-                {
-                    checkForEach: true,
-                    allowVoid: true
-                }
-            ],
-            'block-scoped-var': 'error',
-            'consistent-this': ['error', 'self'],
-            'default-case-last': 'error',
-            eqeqeq: ['error', 'always'],
-            'for-direction': 'error',
-            'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
-            'grouped-accessor-pairs': ['error', 'getBeforeSet'],
-            'guard-for-in': 'error',
-            'init-declarations': 'off',
-            'logical-assignment-operators': ['error', 'always', { enforceForIfStatements: true }],
-            'max-params': 'off',
-            'new-cap': ['error', { newIsCap: true, capIsNew: false, properties: true }],
-            'no-alert': 'error',
-            'no-async-promise-executor': 'error',
-            'no-caller': 'error',
-            'no-case-declarations': 'error',
-            'no-class-assign': 'error',
-            'no-compare-neg-zero': 'error',
-            'no-cond-assign': ['error', 'always'],
-            'no-constant-binary-expression': 'error',
-            'no-constant-condition': 'error',
-            'no-constructor-return': 'error',
-            'no-control-regex': 'error',
-            'no-debugger': 'error',
-            'no-delete-var': 'error',
-            'no-dupe-else-if': 'error',
-            'no-duplicate-case': 'error',
-            'no-duplicate-imports': ['error', { includeExports: false }],
-            'no-else-return': 'error',
-            'no-empty': ['error', { allowEmptyCatch: true }],
-            'no-empty-character-class': 'error',
-            'no-empty-pattern': 'error',
-            'no-empty-static-block': 'error',
-            'no-eval': 'error',
-            'no-ex-assign': 'error',
-            'no-extend-native': 'error',
-            'no-extra-bind': 'error',
-            'no-extra-boolean-cast': 'error',
-            'no-fallthrough': ['error', { allowEmptyCase: true }],
-            'no-global-assign': 'error',
-            'no-implicit-coercion': ['error', { disallowTemplateShorthand: true }],
-            'no-import-assign': 'error',
-            'no-inner-declarations': ['error', 'both'],
-            'no-invalid-regexp': 'error',
-            'no-irregular-whitespace': 'error',
-            'no-iterator': 'error',
-            'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
-            'no-lone-blocks': 'error',
-            'no-lonely-if': 'error',
-            'no-misleading-character-class': 'error',
-            'no-multi-assign': 'error',
-            'no-multi-str': 'error',
-            'no-new': 'error',
-            'no-new-func': 'error',
-            'no-new-native-nonconstructor': 'error',
-            'no-new-wrappers': 'error',
-            'no-nonoctal-decimal-escape': 'error',
-            'no-object-constructor': 'error',
-            'no-octal': 'error',
-            'no-octal-escape': 'error',
-            'no-promise-executor-return': ['error', { allowVoid: true }],
-            'no-proto': 'error',
-            'no-prototype-builtins': 'error',
-            'no-regex-spaces': 'error',
-            'no-script-url': 'error',
-            'no-self-assign': 'error',
-            'no-self-compare': 'error',
-            'no-sequences': 'error',
-            'no-shadow-restricted-names': 'error',
-            'no-sparse-arrays': 'error',
-            'no-template-curly-in-string': 'error',
-            'no-undef-init': 'error',
-            'no-undefined': 'error',
-            'no-unexpected-multiline': 'error',
-            'no-unmodified-loop-condition': 'error',
-            'no-unneeded-ternary': ['error', { defaultAssignment: false }],
-            'no-unreachable-loop': 'error',
-            'no-unsafe-finally': 'error',
-            'no-unsafe-optional-chaining': ['error', { disallowArithmeticOperators: true }],
-            'no-unused-vars': 'off',
-            'no-useless-backreference': 'error',
-            'no-useless-call': 'error',
-            'no-useless-catch': 'error',
-            'no-useless-computed-key': 'error',
-            'no-useless-concat': 'error',
-            'no-useless-rename': 'error',
-            'no-useless-return': 'error',
-            'no-var': 'error',
-            'no-with': 'error',
-            'object-shorthand': ['error', 'always'],
-            'operator-assignment': ['error', 'always'],
-            'prefer-arrow-callback': 'error',
-            'prefer-const': [
-                'error',
-                {
-                    destructuring: 'all',
-                    ignoreReadBeforeAssign: true
-                }
-            ],
-            'prefer-destructuring': 'off',
-            'prefer-exponentiation-operator': 'error',
-            'prefer-object-has-own': 'error',
-            'prefer-object-spread': 'error',
-            'prefer-promise-reject-errors': 'error',
-            'prefer-regex-literals': ['error', { disallowRedundantWrapping: true }],
-            'prefer-rest-params': 'error',
-            'prefer-spread': 'error',
-            'prefer-template': 'error',
-            'require-atomic-updates': 'error',
-            'sort-imports': [
-                'error',
-                {
-                    allowSeparatedGroups: false,
-                    ignoreCase: false,
-                    ignoreDeclarationSort: true,
-                    ignoreMemberSort: false,
-                    memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single']
-                }
-            ],
-            'symbol-description': 'error',
-            'use-isnan': 'error',
-            'valid-typeof': 'error',
-            yoda: ['error', 'never'],
-            ...overrides?.javascript
-        }
-    };
-}
-
-/**
- * @see https://eslint-plugin-perfectionist.azat.io/rules/
- */
-async function perfectionist(options) {
-    const { overrides, perfectionist: enabled = true } = options;
-    if (!enabled)
-        return {};
-    const plugin = await interopDefault(import('eslint-plugin-perfectionist'));
-    return {
-        plugins: {
-            perfectionist: plugin
-        },
-        rules: {
-            'perfectionist/sort-classes': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc',
-                    groups: [
-                        'index-signature',
-                        'property',
-                        'private-property',
-                        'constructor',
-                        'method',
-                        'private-method',
-                        ['get-method', 'set-method'],
-                        'static-property',
-                        'static-method',
-                        'static-private-method',
-                        'unknown'
-                    ]
-                }
-            ],
-            'perfectionist/sort-enums': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc'
-                }
-            ],
-            'perfectionist/sort-exports': [
-                'error',
-                {
-                    type: 'line-length',
-                    order: 'asc'
-                }
-            ],
-            'perfectionist/sort-imports': [
-                'error',
-                {
-                    type: 'line-length',
-                    order: 'asc',
-                    'newlines-between': 'never',
-                    groups: [
-                        ['style', 'side-effect'],
-                        ['builtin', 'builtin-type'],
-                        ['external', 'external-type'],
-                        ['internal', 'internal-type'],
-                        'unknown'
-                    ]
-                }
-            ],
-            'perfectionist/sort-interfaces': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc',
-                    'partition-by-new-line': true
-                }
-            ],
-            'perfectionist/sort-maps': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc'
-                }
-            ],
-            'perfectionist/sort-named-exports': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc'
-                }
-            ],
-            'sort-imports': 'off',
-            'perfectionist/sort-named-imports': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc'
-                }
-            ],
-            '@typescript-eslint/adjacent-overload-signatures': 'off',
-            'perfectionist/sort-object-types': [
-                'error',
-                {
-                    type: 'natural',
-                    order: 'asc',
-                    'partition-by-new-line': true
-                }
-            ],
-            ...overrides?.perfectionist
-        }
-    };
-}
-
-/**
- * @see https://typescript-eslint.io/rules/
- */
-async function typescript(options) {
-    const { project, overrides } = options;
-    const [tsParser, tsPlugin] = await Promise.all([
-        await interopDefault(import('@typescript-eslint/parser')),
-        await interopDefault(import('@typescript-eslint/eslint-plugin'))
-    ]);
-    const files = [Glob.TYPESCRIPT];
-    if (options.vue)
-        files.push(Glob.VUE);
-    const rules = {
-        '@typescript-eslint/adjacent-overload-signatures': 'error',
-        'no-array-constructor': 'off',
-        '@typescript-eslint/no-array-constructor': 'error',
-        '@typescript-eslint/array-type': ['error', { default: 'array' }],
-        '@typescript-eslint/ban-ts-comment': [
-            'error',
-            {
-                'ts-expect-error': 'allow-with-description',
-                'ts-ignore': true,
-                'ts-nocheck': true,
-                'ts-check': false,
-                minimumDescriptionLength: 3
-            }
-        ],
-        '@typescript-eslint/class-literal-property-style': ['error', 'fields'],
-        'class-methods-use-this': 'off',
-        '@typescript-eslint/class-methods-use-this': [
-            'error',
-            {
-                ignoreOverrideMethods: true,
-                ignoreClassesThatImplementAnInterface: 'public-fields'
-            }
-        ],
-        '@typescript-eslint/consistent-generic-constructors': ['error', 'constructor'],
-        '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
-        '@typescript-eslint/consistent-type-assertions': [
-            'error',
-            { assertionStyle: 'as', objectLiteralTypeAssertions: 'allow-as-parameter' }
-        ],
-        '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
-        'dot-notation': 'off',
-        '@typescript-eslint/dot-notation': ['error', { allowKeywords: true }],
-        '@typescript-eslint/explicit-function-return-type': 'off',
-        '@typescript-eslint/explicit-member-accessibility': [
-            'error',
-            {
-                accessibility: 'explicit',
-                overrides: {
-                    accessors: 'no-public',
-                    constructors: 'no-public',
-                    methods: 'explicit',
-                    properties: 'explicit',
-                    parameterProperties: 'explicit'
-                }
-            }
-        ],
-        '@typescript-eslint/explicit-module-boundary-types': 'off',
-        '@typescript-eslint/method-signature-style': ['error', 'property'],
-        '@typescript-eslint/no-base-to-string': 'error',
-        '@typescript-eslint/no-confusing-non-null-assertion': 'error',
-        '@typescript-eslint/no-confusing-void-expression': [
-            'error',
-            {
-                ignoreArrowShorthand: true,
-                ignoreVoidOperator: true
-            }
-        ],
-        '@typescript-eslint/no-duplicate-enum-values': 'error',
-        '@typescript-eslint/no-duplicate-type-constituents': 'error',
-        '@typescript-eslint/no-dynamic-delete': 'error',
-        'no-empty-function': 'off',
-        '@typescript-eslint/no-empty-function': 'error',
-        '@typescript-eslint/no-empty-interface': 'error',
-        '@typescript-eslint/no-explicit-any': ['error', { fixToUnknown: true }],
-        '@typescript-eslint/no-extra-non-null-assertion': 'error',
-        '@typescript-eslint/no-extraneous-class': 'error',
-        '@typescript-eslint/no-floating-promises': ['error', { ignoreVoid: true }],
-        '@typescript-eslint/no-for-in-array': 'error',
-        'no-implied-eval': 'off',
-        '@typescript-eslint/no-implied-eval': 'error',
-        '@typescript-eslint/no-import-type-side-effects': 'error',
-        '@typescript-eslint/no-inferrable-types': 'error',
-        '@typescript-eslint/no-invalid-void-type': [
-            'error',
-            {
-                allowInGenericTypeArguments: true,
-                allowAsThisParameter: true
-            }
-        ],
-        'no-loop-func': 'off',
-        '@typescript-eslint/no-loop-func': 'error',
-        'no-loss-of-precision': 'off',
-        '@typescript-eslint/no-loss-of-precision': 'error',
-        '@typescript-eslint/no-meaningless-void-operator': 'error',
-        '@typescript-eslint/no-misused-new': 'error',
-        '@typescript-eslint/no-misused-promises': [
-            'error',
-            {
-                checksConditionals: true,
-                checksSpreads: true,
-                checksVoidReturn: {
-                    arguments: true,
-                    attributes: true,
-                    properties: true,
-                    returns: true,
-                    variables: true
-                }
-            }
-        ],
-        '@typescript-eslint/no-mixed-enums': 'error',
-        '@typescript-eslint/no-namespace': 'error',
-        '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
-        '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
-        '@typescript-eslint/no-non-null-assertion': 'error',
-        '@typescript-eslint/no-redundant-type-constituents': 'error',
-        '@typescript-eslint/no-require-imports': 'error',
-        'no-shadow': 'off',
-        '@typescript-eslint/no-shadow': 'error',
-        '@typescript-eslint/no-this-alias': 'error',
-        'no-throw-literal': 'off',
-        '@typescript-eslint/no-throw-literal': 'error',
-        '@typescript-eslint/no-unnecessary-boolean-literal-compare': [
-            'error',
-            {
-                allowComparingNullableBooleansToTrue: false,
-                allowComparingNullableBooleansToFalse: true
-            }
-        ],
-        '@typescript-eslint/no-unnecessary-condition': 'error',
-        '@typescript-eslint/no-unnecessary-qualifier': 'error',
-        '@typescript-eslint/no-unnecessary-type-arguments': 'error',
-        '@typescript-eslint/no-unnecessary-type-assertion': 'error',
-        '@typescript-eslint/no-unnecessary-type-constraint': 'error',
-        '@typescript-eslint/no-unsafe-argument': 'off',
-        '@typescript-eslint/no-unsafe-assignment': 'error',
-        '@typescript-eslint/no-unsafe-call': 'error',
-        '@typescript-eslint/no-unsafe-declaration-merging': 'error',
-        '@typescript-eslint/no-unsafe-enum-comparison': 'off',
-        '@typescript-eslint/no-unsafe-member-access': 'error',
-        '@typescript-eslint/no-unsafe-return': 'error',
-        '@typescript-eslint/no-unsafe-unary-minus': 'error',
-        'no-unused-expressions': 'off',
-        '@typescript-eslint/no-unused-expressions': [
-            'error',
-            {
-                allowTaggedTemplates: true
-            }
-        ],
-        'no-use-before-define': 'off',
-        '@typescript-eslint/no-use-before-define': [
-            'error',
-            {
-                functions: false,
-                enums: true,
-                typedefs: false
-            }
-        ],
-        'no-useless-constructor': 'off',
-        '@typescript-eslint/no-useless-constructor': 'error',
-        '@typescript-eslint/no-useless-empty-export': 'error',
-        '@typescript-eslint/non-nullable-type-assertion-style': 'error',
-        '@typescript-eslint/prefer-as-const': 'error',
-        '@typescript-eslint/prefer-enum-initializers': 'error',
-        '@typescript-eslint/prefer-for-of': 'error',
-        '@typescript-eslint/prefer-function-type': 'error',
-        '@typescript-eslint/prefer-includes': 'error',
-        '@typescript-eslint/prefer-literal-enum-member': 'error',
-        '@typescript-eslint/prefer-nullish-coalescing': [
-            'error',
-            {
-                ignoreTernaryTests: false,
-                ignoreConditionalTests: false,
-                ignoreMixedLogicalExpressions: false,
-                ignorePrimitives: {
-                    bigint: false,
-                    boolean: false,
-                    number: false,
-                    string: false
-                }
-            }
-        ],
-        '@typescript-eslint/prefer-optional-chain': 'error',
-        '@typescript-eslint/prefer-readonly': 'error',
-        '@typescript-eslint/prefer-readonly-parameter-types': 'off',
-        '@typescript-eslint/prefer-reduce-type-parameter': 'error',
-        '@typescript-eslint/prefer-regexp-exec': 'error',
-        '@typescript-eslint/prefer-return-this-type': 'error',
-        '@typescript-eslint/prefer-string-starts-ends-with': 'error',
-        '@typescript-eslint/prefer-ts-expect-error': 'error',
-        '@typescript-eslint/promise-function-async': 'off',
-        '@typescript-eslint/require-array-sort-compare': 'error',
-        'require-await': 'off',
-        '@typescript-eslint/require-await': 'error',
-        '@typescript-eslint/restrict-plus-operands': 'error',
-        '@typescript-eslint/restrict-template-expressions': 'error',
-        '@typescript-eslint/strict-boolean-expressions': 'off',
-        '@typescript-eslint/switch-exhaustiveness-check': [
-            'error',
-            {
-                requireDefaultForNonUnion: true
-            }
-        ],
-        '@typescript-eslint/unbound-method': 'error',
-        '@typescript-eslint/unified-signatures': [
-            'error',
-            {
-                ignoreDifferentlyNamedParameters: true
-            }
-        ],
-        ...overrides?.typescript
-    };
-    return {
-        files,
-        languageOptions: {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            parser: tsParser,
-            parserOptions: {
-                project,
-                tsconfigRootDir: process.cwd(),
-                extraFileExtensions: options.vue ? ['.vue'] : []
-            }
-        },
-        plugins: {
-            '@typescript-eslint': tsPlugin
-        },
-        rules
-    };
-}
-
-/**
- * @see https://github.com/sindresorhus/eslint-plugin-unicorn#rules
- */
-async function unicorn(options) {
-    const { overrides, unicorn: enabled = true } = options;
-    if (!enabled)
-        return {};
-    const plugin = await interopDefault(import('eslint-plugin-unicorn'));
-    return {
-        plugins: {
-            unicorn: plugin
-        },
-        rules: {
-            'unicorn/catch-error-name': [
-                'error',
-                {
-                    name: 'err'
-                }
-            ],
-            'unicorn/consistent-function-scoping': [
-                'error',
-                {
-                    checkArrowFunctions: true
-                }
-            ],
-            'unicorn/custom-error-definition': 'error',
-            'unicorn/error-message': 'error',
-            'unicorn/no-array-for-each': 'error',
-            'unicorn/no-array-method-this-argument': 'error',
-            'unicorn/no-array-push-push': 'error',
-            'unicorn/no-await-expression-member': 'error',
-            'unicorn/no-invalid-remove-event-listener': 'error',
-            'unicorn/no-thenable': 'error',
-            'unicorn/no-typeof-undefined': 'error',
-            'unicorn/no-useless-fallback-in-spread': 'error',
-            'unicorn/no-useless-length-check': 'error',
-            'unicorn/no-useless-promise-resolve-reject': 'error',
-            'unicorn/prefer-at': 'error',
-            'unicorn/prefer-date-now': 'error',
-            'unicorn/prefer-dom-node-append': 'error',
-            'unicorn/prefer-dom-node-dataset': 'error',
-            'unicorn/prefer-dom-node-remove': 'error',
-            'unicorn/prefer-dom-node-text-content': 'error',
-            'unicorn/prefer-modern-dom-apis': 'error',
-            'unicorn/prefer-node-protocol': 'error',
-            'unicorn/prefer-number-properties': 'error',
-            'unicorn/prefer-object-from-entries': 'error',
-            'unicorn/prefer-prototype-methods': 'error',
-            'unicorn/prefer-query-selector': 'error',
-            'unicorn/prefer-reflect-apply': 'error',
-            'unicorn/prefer-regexp-test': 'error',
-            'unicorn/prefer-string-slice': 'error',
-            'unicorn/prefer-type-error': 'error',
-            'unicorn/relative-url-style': ['error', 'never'],
-            ...overrides?.unicorn
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/**
- * @see https://eslint.vuejs.org/rules/
- */
-async function vue(options) {
-    const { overrides, vue: enabled } = options;
-    if (!enabled)
-        return [];
-    const [vuePlugin, vueParser, tsParser] = await Promise.all([
-        // @ts-expect-error no types
-        await interopDefault(import('eslint-plugin-vue')),
-        await interopDefault(import('vue-eslint-parser')),
-        await interopDefault(import('@typescript-eslint/parser'))
-    ]);
-    const rules = {
-        ...vuePlugin.configs.base.rules,
-        'vue/attribute-hyphenation': ['error', 'always'],
-        'vue/attributes-order': 'error',
-        'vue/block-lang': [
-            'error',
-            {
-                script: {
-                    lang: 'ts'
-                },
-                style: {
-                    lang: 'scss',
-                    allowNoLang: true
-                }
-            }
-        ],
-        'vue/block-order': [
-            'error',
-            {
-                order: [['script', 'template'], 'style:not([scoped])', 'style[scoped]']
-            }
-        ],
-        'vue/block-tag-newline': [
-            'error',
-            {
-                singleline: 'always',
-                multiline: 'always',
-                maxEmptyLines: 0
-            }
-        ],
-        'vue/component-api-style': ['error', ['script-setup']],
-        'vue/component-definition-name-casing': ['error', 'PascalCase'],
-        'vue/component-name-in-template-casing': ['error', 'PascalCase'],
-        'vue/custom-event-name-casing': ['error', 'camelCase'],
-        'vue/define-emits-declaration': ['error', 'type-based'],
-        'vue/define-macros-order': [
-            'error',
-            {
-                order: ['defineProps', 'defineEmits']
-            }
-        ],
-        'vue/define-props-declaration': ['error', 'type-based'],
-        'vue/first-attribute-linebreak': 'off',
-        'vue/html-button-has-type': [
-            'error',
-            {
-                button: true,
-                submit: true,
-                reset: true
-            }
-        ],
-        'vue/html-closing-bracket-newline': [
-            'error',
-            {
-                singleline: 'never',
-                multiline: 'always'
-            }
-        ],
-        'vue/html-closing-bracket-spacing': [
-            'error',
-            {
-                startTag: 'never',
-                endTag: 'never',
-                selfClosingTag: 'always'
-            }
-        ],
-        'vue/html-self-closing': [
-            'error',
-            {
-                html: {
-                    void: 'never',
-                    normal: 'always',
-                    component: 'always'
-                },
-                svg: 'always',
-                math: 'always'
-            }
-        ],
-        'vue/match-component-file-name': [
-            'error',
-            {
-                extensions: ['tsx', 'vue'],
-                shouldMatchCase: false
-            }
-        ],
-        'vue/match-component-import-name': 'error',
-        'vue/multi-word-component-names': 'off',
-        'vue/mustache-interpolation-spacing': ['error', 'always'],
-        'vue/no-arrow-functions-in-watch': 'off',
-        'vue/no-async-in-computed-properties': 'error',
-        'vue/no-boolean-default': ['error', 'no-default'],
-        'vue/no-computed-properties-in-data': 'error',
-        'vue/no-dupe-keys': 'error',
-        'vue/no-dupe-v-else-if': 'error',
-        'vue/no-duplicate-attributes': [
-            'error',
-            {
-                allowCoexistClass: true,
-                allowCoexistStyle: true
-            }
-        ],
-        'vue/no-export-in-script-setup': 'error',
-        'vue/no-expose-after-await': 'error',
-        'vue/no-lifecycle-after-await': 'error',
-        'vue/no-lone-template': 'error',
-        'vue/no-multi-spaces': 'error',
-        'vue/no-multiple-objects-in-class': 'error',
-        'vue/no-mutating-props': 'error',
-        'vue/no-parsing-error': 'error',
-        'vue/no-ref-as-operand': 'error',
-        'vue/no-ref-object-reactivity-loss': 'error',
-        'vue/no-reserved-component-names': 'error',
-        'vue/no-reserved-keys': 'error',
-        'vue/no-reserved-props': 'error',
-        'vue/no-required-prop-with-default': [
-            'error',
-            {
-                autofix: true
-            }
-        ],
-        'vue/no-root-v-if': 'error',
-        'vue/no-setup-props-reactivity-loss': 'error',
-        'vue/no-shared-component-data': 'error',
-        'vue/no-side-effects-in-computed-properties': 'error',
-        'vue/no-spaces-around-equal-signs-in-attribute': 'error',
-        'vue/no-static-inline-styles': [
-            'error',
-            {
-                allowBinding: false
-            }
-        ],
-        'vue/no-template-key': 'error',
-        'vue/no-template-shadow': 'error',
-        'vue/no-template-target-blank': 'error',
-        'vue/no-textarea-mustache': 'error',
-        'vue/no-unused-components': 'error',
-        'vue/no-unused-emit-declarations': 'error',
-        'vue/no-unused-properties': 'error',
-        'vue/no-unused-refs': 'error',
-        'vue/no-unused-vars': [
-            'error',
-            {
-                ignorePattern: '^_'
-            }
-        ],
-        'vue/no-use-computed-property-like-method': 'error',
-        'vue/no-use-v-else-with-v-for': 'error',
-        'vue/no-use-v-if-with-v-for': 'error',
-        'vue/no-useless-mustaches': [
-            'error',
-            {
-                ignoreIncludesComment: false,
-                ignoreStringEscape: false
-            }
-        ],
-        'vue/no-useless-template-attributes': 'error',
-        'vue/no-useless-v-bind': 'error',
-        'vue/no-v-for-template-key-on-child': 'error',
-        'vue/no-v-text-v-html-on-component': 'error',
-        'vue/no-v-html': 'off',
-        'vue/no-watch-after-await': 'error',
-        'vue/order-in-components': 'error',
-        'vue/padding-line-between-blocks': ['error', 'always'],
-        'vue/prefer-define-options': 'error',
-        'vue/prefer-import-from-vue': 'error',
-        'vue/prefer-separate-static-class': 'error',
-        'vue/prefer-true-attribute-shorthand': 'error',
-        'vue/prop-name-casing': ['error', 'camelCase'],
-        'vue/require-component-is': 'error',
-        'vue/require-default-prop': 'off',
-        'vue/require-explicit-emits': [
-            'error',
-            {
-                allowProps: false
-            }
-        ],
-        'vue/require-macro-variable-name': [
-            'error',
-            {
-                defineProps: 'props',
-                defineEmits: 'emit',
-                defineSlots: 'slots',
-                useSlots: 'slots',
-                useAttrs: 'attrs'
-            }
-        ],
-        'vue/require-prop-types': 'error',
-        'vue/require-render-return': 'error',
-        'vue/require-slots-as-functions': 'error',
-        'vue/require-toggle-inside-transition': 'error',
-        'vue/require-typed-ref': 'error',
-        'vue/require-v-for-key': 'error',
-        'vue/require-valid-default-prop': 'error',
-        'vue/return-in-computed-property': 'error',
-        'vue/return-in-emits-validator': 'error',
-        'vue/this-in-template': ['error', 'never'],
-        'vue/use-v-on-exact': 'error',
-        'vue/v-bind-style': ['error', 'shorthand'],
-        'vue/v-for-delimiter-style': ['error', 'of'],
-        'vue/v-on-handler-style': [
-            'error',
-            ['method', 'inline-function'],
-            {
-                ignoreIncludesComment: false
-            }
-        ],
-        'vue/v-on-style': ['error', 'shorthand'],
-        'vue/v-slot-style': [
-            'error',
-            {
-                atComponent: 'shorthand',
-                default: 'shorthand',
-                named: 'shorthand'
-            }
-        ],
-        'vue/v-on-event-hyphenation': ['error', 'always'],
-        'vue/valid-attribute-name': 'error',
-        'vue/valid-define-emits': 'error',
-        'vue/valid-define-options': 'error',
-        'vue/valid-define-props': 'error',
-        'vue/valid-next-tick': 'error',
-        'vue/valid-template-root': 'error',
-        'vue/valid-v-bind': 'error',
-        'vue/valid-v-cloak': 'error',
-        'vue/valid-v-else-if': 'error',
-        'vue/valid-v-else': 'error',
-        'vue/valid-v-for': 'error',
-        'vue/valid-v-html': 'error',
-        'vue/valid-v-if': 'error',
-        'vue/valid-v-memo': 'error',
-        'vue/valid-v-model': 'error',
-        'vue/valid-v-on': 'error',
-        'vue/valid-v-once': 'error',
-        'vue/valid-v-pre': 'error',
-        'vue/valid-v-show': 'error',
-        'vue/valid-v-slot': 'error',
-        'vue/valid-v-text': 'error',
-        ...overrides?.vue
-    };
-    return [
-        {
-            plugins: {
-                vue: vuePlugin
-            }
-        },
-        {
-            files: [Glob.VUE],
-            languageOptions: {
-                parser: vueParser,
-                parserOptions: {
-                    parser: tsParser,
-                    project: options.project,
-                    tsconfigRootDir: process.cwd(),
-                    extraFileExtensions: ['.vue'],
-                    sourceType: 'module',
-                    ecmaVersion: 'latest'
-                }
-            }
-        },
-        {
-            // @ts-expect-error no types
-            processor: vuePlugin.processors['.vue'],
-            rules
-        }
-    ];
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-async function config(options) {
-    const { prettier = true } = options;
-    const objs = await Promise.all([
-        javascript(options),
-        typescript(options),
-        ...(await vue(options)),
-        perfectionist(options),
-        unicorn(options),
-        prettier ? eslintConfigPrettier : {},
-        {
-            ignores: [...getIgnores(), ...(options.ignores ?? [])]
-        }
-    ]);
-    return objs;
-}
-
-export { config as default };