.eslintrc.js

// Typescript and Shared rules
const
    sharedRules = {
        'accessor-pairs': [ 'warn', { enforceForClassMembers: true, },],
        'array-bracket-newline': [
            'warn',
            {
                minItems: 3,
                multiline: true,
            },
        ],
        'array-bracket-spacing': [
            'warn',
            'always',
            {
                arraysInArrays: true,
                objectsInArrays: false,
                singleValue: true,
            },
        ],
        'array-callback-return': [ 'warn', { allowImplicit: true, },],
        'array-element-newline': [
            'warn',
            {
                minItems: 3,
                multiline: true,
            },
        ],
        'arrow-parens': [ 'warn', 'as-needed' ],
        'arrow-spacing': [
            1,
            {
                after: true,
                before: true,
            },
        ],
        'block-scoped-var': 'warn',
        'block-spacing': [ 'warn', 'always' ],
        'brace-style': [
            'warn',
            '1tbs',
            { allowSingleLine: true, },
        ],
        camelcase: [ 'off', { ignoreDestructuring: true, },],
        'capitalized-comments': [
            'off',
            'always',
            {
                ignoreConsecutiveComments: true,
                ignoreInlineComments: true,
                ignorePattern: /pragma|ignore|prettier-ignore|webpack\w+:|c8/.source,
            },
        ],
        'comma-dangle': 'off',
        'comma-spacing': [
            'warn',
            {
                after: true,
                before: false,
            },
        ],
        'comma-style': [
            'warn',
            'first',
            {
                exceptions: {
                    ArrayExpression: true,
                    ObjectExpression: true,
                },
            },
        ],
        'compat/compat': 'warn',
        complexity: [ 'off', 45 ],
        'computed-property-spacing': [ 'warn', 'always' ],
        'constructor-super': 'warn',
        curly: [ 'warn', 'multi-or-nest' ],
        'default-case': 'warn',
        'default-param-last': 'warn',
        'dot-location': [ 'warn', 'property' ],
        'dot-notation': 'warn',
        'eol-last': 'warn',
        eqeqeq: [ 'warn', 'always' ],
        'eslint-comments/disable-enable-pair': [ 'warn', { allowWholeFile: true, },],
        'eslint-comments/no-aggregating-enable': 'warn',
        'eslint-comments/no-duplicate-disable': 'warn',
        'eslint-comments/no-unused-disable': 'warn',
        'for-direction': 'warn',
        'func-call-spacing': [ 'warn', 'never' ],
        'func-name-matching': [ 'warn', { considerPropertyDescriptor: true, },],
        'func-names': [ 'warn', 'never' ],
        'function-call-argument-newline': [ 'warn', 'consistent' ],
        'function-paren-newline': [ 'warn', 'multiline-arguments' ],
        'generator-star-spacing': [ 'warn', 'both' ],
        'getter-return': 'warn',
        'grouped-accessor-pairs': [ 'warn', 'getBeforeSet' ],
        'guard-for-in': 'warn',
        'import/default': 'warn',
        'import/export': 'warn',
        'import/extensions': [
            'warn',
            {
                ignorePackages: true,
                pattern: {
                    css: 'always',
                    gql: 'always',
                    js: 'never',
                    json: 'always',
                    jsx: 'never',
                    md: 'always',
                    module: 'always',
                    svg: 'always',
                    vue: 'always',
                },
            },
        ],
        'import/first': 'warn',
        'import/namespace': [ 'warn', { allowComputed: true, },],
        'import/no-absolute-path': 'warn',
        'import/no-anonymous-default-export': 'off',
        'import/no-extraneous-dependencies': 'off',
        'import/no-mutable-exports': 'warn',
        'import/no-named-as-default': 'warn',
        'import/no-named-as-default-member': 'warn',
        'import/no-named-default': 'warn',
        'import/no-self-import': 'warn',
        'import/no-unassigned-import': [
            'warn',
            {
                allow: [
                    '**/register',
                    '**/register/**',
                    '**/*.css',
                    '**/*.scss',
                    '**/*.sass',
                    '**/*.postcss',
                    '**/*.less',
                    '**/css',
                    '**/scss',
                ],
            },
        ],
        'import/no-useless-path-segments': [ 'warn', { noUselessIndex: true, },],
        'import/no-webpack-loader-syntax': 'warn',
        'import-newlines/enforce': [ 'warn', { forceSingleLine: false, }],
        indent: [
            'warn',
            4,
            { SwitchCase: 1, },
        ],
        'jsx-quotes': 'warn',
        'key-spacing': [ 'warn', { beforeColon: false, },],
        'keyword-spacing': [
            'warn',
            {
                after: false,
                overrides: {
                    case: { after: true, },
                    catch: {
                        after: false,
                        before: true,
                    },
                    const: { after: true, },
                    default: { after: true, },
                    else: {
                        after: true,
                        before: true,
                    },
                    export: { after: true, },
                    finally: { after: true, },
                    from: {
                        after: true,
                        before: true,
                    },
                    import: { after: true, },
                    return: { after: true, },
                    try: { after: true, },
                },
            },
        ],
        'lines-around-comment': [
            'warn',
            {
                afterBlockComment: false,
                afterLineComment: false,
                allowArrayEnd: true,
                allowArrayStart: true,
                allowBlockEnd: true,
                allowBlockStart: true,
                allowObjectEnd: true,
                allowObjectStart: true,
                beforeBlockComment: false,
                beforeLineComment: false,
            },
        ],
        'lines-between-class-members': [
            'warn',
            'always',
            { exceptAfterSingleLine: true, },
        ],
        'max-depth': [ 'warn', { max: 7, },],
        'max-len': [
            'off',
            1200,
            4,
            {
                ignoreStrings: true,
                ignoreTemplateLiterals: true,
                ignoreUrls: true,
            },
        ],
        'max-nested-callbacks': [ 'warn', 7 ],
        'max-params': [ 'warn', { max: 7, },],
        'max-statements': [
            'warn',
            72,
            { ignoreTopLevelFunctions: true, },
        ],
        'max-statements-per-line': 'warn',
        'new-cap': [ 'warn', { newIsCap: true, },],
        'new-parens': 'warn',
        'no-alert': 'warn',
        'no-array-constructor': 'warn',
        'no-async-promise-executor': 'warn',
        'no-await-in-loop': 'warn',
        'no-buffer-constructor': 'warn',
        'no-caller': 'warn',
        'no-case-declarations': 'warn',
        'no-class-assign': 'warn',
        'no-compare-neg-zero': 'warn',
        'no-cond-assign': 'warn',
        'no-confusing-arrow': 'warn',
        'no-console': [
            'warn',
            {
                allow: [
                    'info',
                    'error',
                    'warn',
                ],
            },
        ],
        'no-const-assign': 'warn',
        'no-constant-condition': 'warn',
        'no-constructor-return': 'warn',
        'no-control-regex': 'warn',
        'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'warn',
        'no-delete-var': 'warn',
        'no-dupe-args': 'warn',
        'no-dupe-class-members': 'warn',
        'no-dupe-else-if': 'warn',
        'no-dupe-keys': 'warn',
        'no-duplicate-case': 'warn',
        'no-duplicate-imports': [ 'warn', { includeExports: true, },],
        'no-else-return': [ 'warn', { allowElseIf: false, },],
        'no-empty': 'warn',
        'no-empty-character-class': 'warn',
        'no-empty-pattern': 'warn',
        'no-eq-null': 'warn',
        'no-eval': 'warn',
        'no-ex-assign': 'warn',
        'no-extend-native': 'warn',
        'no-extra-bind': 'warn',
        'no-extra-boolean-cast': 'warn',
        'no-extra-label': 'warn',
        'no-extra-parens': [ 'warn', 'functions' ],
        'no-extra-semi': 'warn',
        'no-fallthrough': 'warn',
        'no-floating-decimal': 'warn',
        'no-func-assign': 'warn',
        'no-global-assign': 'warn',
        'no-implicit-coercion': [ 'warn', { allow: [ '!!', '~' ], },],
        'no-implicit-globals': 'warn',
        'no-implied-eval': 'warn',
        'no-import-assign': 'warn',
        'no-inner-declarations': [ 'warn', 'functions' ],
        'no-invalid-regexp': 'warn',
        'no-irregular-whitespace': 'warn',
        'no-iterator': 'warn',
        'no-label-var': 'warn',
        'no-labels': 'warn',
        'no-lone-blocks': 'warn',
        'no-lonely-if': 'warn',
        'no-loss-of-precision': 'warn',
        'no-misleading-character-class': 'warn',
        'no-mixed-operators': 'warn',
        'no-mixed-spaces-and-tabs': 'warn',
        'no-multi-assign': 'warn',
        'no-multi-spaces': 'warn',
        'no-multi-str': 'warn',
        'no-multiple-empty-lines': [
            'warn',
            {
                max: 1,
                maxBOF: 1,
                maxEOF: 1,
            },
        ],
        'no-negated-condition': 'warn',
        'no-new': 'warn',
        'no-new-func': 'warn',
        'no-new-object': 'warn',
        'no-new-symbol': 'warn',
        'no-new-wrappers': 'warn',
        'no-obj-calls': 'warn',
        'no-octal': 'warn',
        'no-octal-escape': 'warn',
        'no-promise-executor-return': 'warn',
        'no-proto': 'warn',
        'no-prototype-builtins': 'warn',
        'no-redeclare': 'warn',
        'no-regex-spaces': 'warn',
        'no-restricted-globals': [ 'warn', 'event' ],
        'no-restricted-imports': [
            'warn',
            'domain',
            'freelist',
            'smalloc',
            'sys',
            'colors',
        ],
        'no-restricted-syntax': [ 'warn', 'WithStatement' ],
        'no-return-assign': [ 'warn', 'except-parens' ],
        'no-return-await': 'warn',
        'no-script-url': 'warn',
        'no-self-assign': [ 'warn', { props: true, },],
        'no-self-compare': 'warn',
        'no-sequences': 'warn',
        'no-setter-return': 'warn',
        'no-shadow-restricted-names': 'warn',
        'no-sparse-arrays': 'warn',
        'no-tabs': 'warn',
        'no-template-curly-in-string': 'warn',
        'no-this-before-super': 'warn',
        'no-throw-literal': 'warn',
        'no-trailing-spaces': 'warn',
        'no-undef': 'warn',
        'no-undef-init': 'warn',
        'no-unexpected-multiline': 'warn',
        'no-unmodified-loop-condition': 'warn',
        'no-unneeded-ternary': 'warn',
        'no-unreachable': 'warn',
        'no-unreachable-loop': 'warn',
        'no-unsafe-finally': 'warn',
        'no-unsafe-negation': 'warn',
        'no-unused-expressions': [
            'warn',
            {
                allowShortCircuit: true,
                allowTernary: true,
                enforceForJSX: true,
            },
        ],
        'no-unused-labels': 'warn',
        'no-unused-vars': [
            'warn',
            {
                args: 'after-used',
                argsIgnorePattern: '^_',
                caughtErrors: 'all',
                caughtErrorsIgnorePattern: '^_',
                ignoreRestSiblings: true,
                vars: 'all',
            },
        ],
        'no-useless-call': 'warn',
        'no-useless-computed-key': [ 'warn', { enforceForClassMembers: true, },],
        'no-useless-concat': 'warn',
        'no-useless-constructor': 'warn',
        'no-useless-escape': 'warn',
        'no-useless-rename': [ 'warn', { ignoreExport: true, },],
        'no-useless-return': 'warn',
        'no-void': 'warn',
        'no-whitespace-before-property': 'warn',
        'no-with': 'warn',
        'object-curly-newline': [
            'warn',
            {
                ExportDeclaration: {
                    consistent: true,
                    minProperties: 2,
                    multiline: true,
                },
                ImportDeclaration: {
                    consistent: true,
                    minProperties: 4,
                    multiline: true,
                },
                ObjectExpression: {
                    minProperties: 2,
                    multiline: true,
                },
                ObjectPattern: {
                    minProperties: 4,
                    multiline: true,
                },
            },
        ],
        'object-curly-spacing': [ 'warn', 'always' ],
        'object-property-newline': [ 'warn', { allowAllPropertiesOnSameLine: false, },],
        'object-shorthand': [ 'warn', 'always' ],
        'one-var': [
            'warn',
            {
                const: 'consecutive',
                let: 'consecutive',
                separateRequires: true,
                var: 'consecutive',
            },
        ],
        'one-var-declaration-per-line': [ 'warn', 'always' ],
        'operator-assignment': [ 'warn', 'always' ],
        'operator-linebreak': [ 'warn', 'before' ],
        'padded-blocks': [
            'warn',
            {
                blocks: 'always',
                switches: 'never',
            },
        ],
        'padding-line-between-statements': [
            'warn',
            {
                blankLine: 'always',
                next: '*',
                prev: [
                    'const',
                    'let',
                    'var',
                ],
            },
            {
                blankLine: 'any',
                next: [
                    'const',
                    'let',
                    'var',
                ],
                prev: [
                    'const',
                    'let',
                    'var',
                ],
            },
        ],
        'prefer-const': 'warn',
        'prefer-exponentiation-operator': 'warn',
        'prefer-promise-reject-errors': [ 'warn', { allowEmptyReject: true, },],
        'prefer-regex-literals': 'warn',
        'promise/no-new-statics': 'warn',
        'promise/no-return-in-finally': 'warn',
        'promise/no-return-wrap': [ 'warn', { allowReject: true, },],
        'promise/param-names': 'warn',
        'promise/prefer-await-to-then': 'warn',
        'promise/valid-params': 'warn',
        'quote-props': [ 'warn', 'as-needed' ],
        quotes: [
            'warn',
            'single',
            {
                allowTemplateLiterals: true,
                avoidEscape: true,
            },
        ],
        radix: 'warn',
        'require-atomic-updates': 'warn',
        'require-await': 'warn',
        'require-yield': 'warn',
        'rest-spread-spacing': [ 'warn', 'always' ],
        semi: [ 'warn', 'always' ],
        'semi-spacing': [
            'warn',
            {
                after: true,
                before: false,
            },
        ],
        'sort-imports': [ 'warn', { ignoreDeclarationSort: true, }],
        'sort-keys': 'off',
        'sort-keys-fix/sort-keys-fix': [
            'warn',
            'asc',
            { natural: true, }
        ],
        'space-before-blocks': [ 'warn', 'always' ],
        'space-before-function-paren': [
            'warn',
            {
                anonymous: 'never',
                asyncArrow: 'never',
                named: 'never',
            },
        ],
        'space-in-parens': [ 1, 'always' ],
        'space-infix-ops': 'warn',
        'space-unary-ops': [
            'warn',
            {
                nonwords: true,
                words: true,
            },
        ],
        'spaced-comment': [
            'warn',
            'always',
            {
                block: {
                    balanced: true,
                    exceptions: [
                        '-',
                        '+',
                        '*',
                    ],
                    markers: [ '!', '*' ],
                },
                line: {
                    exceptions: [
                        '-',
                        '+',
                        '*',
                    ],
                    markers: [
                        '!',
                        '/',
                        '=>',
                    ],
                },
            },
        ],
        'standard/computed-property-even-spacing': [ 'warn', 'always' ],
        'standard/object-curly-even-spacing': [ 'warn', 'either' ],
        'switch-colon-spacing': [
            'warn',
            {
                after: true,
                before: false,
            },
        ],
        'symbol-description': 'warn',
        'template-curly-spacing': [ 'warn', 'always' ],
        'template-tag-spacing': [ 'warn', 'never' ],
        'unicode-bom': [ 'warn', 'never' ],
        'unicorn/better-regex': [ 'warn', { sortCharacterClasses: false, },],
        'unicorn/catch-error-name': [ 'warn', { name: 'exception', },],
        'unicorn/consistent-destructuring': 'warn',
        'unicorn/consistent-function-scoping': 'off',
        'unicorn/error-message': 'off',
        'unicorn/explicit-length-check': 'off',
        'unicorn/filename-case': [
            'warn',
            {
                cases: {
                    camelCase: true,
                    kebabCase: true,
                    pascalCase: true,
                },
            },
        ],
        'unicorn/import-style': 'off',
        'unicorn/no-abusive-eslint-disable': 'warn',
        'unicorn/no-array-callback-reference': 'off',
        'unicorn/no-array-for-each': 'warn',
        'unicorn/no-array-instanceof': 'off',
        'unicorn/no-array-push-push': 'warn',
        'unicorn/no-array-reduce': 'off',
        'unicorn/no-empty-file': 'warn',
        'unicorn/no-for-loop': 'warn',
        'unicorn/no-hex-escape': 'off',
        'unicorn/no-lonely-if': 'warn',
        'unicorn/no-new-array': 'off',
        'unicorn/no-null': 'off',
        'unicorn/no-object-as-default-parameter': 'off',
        'unicorn/no-useless-fallback-in-spread': 'warn',
        'unicorn/no-useless-undefined': 'off',
        'unicorn/no-zero-fractions': 'warn',
        'unicorn/numeric-separators-style': 'warn',
        'unicorn/prefer-add-event-listener': 'warn',
        'unicorn/prefer-array-find': 'warn',
        'unicorn/prefer-array-flat-map': 'warn',
        'unicorn/prefer-array-index-of': 'warn',
        'unicorn/prefer-date-now': 'warn',
        'unicorn/prefer-dom-node-append': 'warn',
        'unicorn/prefer-dom-node-remove': 'warn',
        'unicorn/prefer-exponentiation-operator': 'off',
        'unicorn/prefer-export-from': 'warn',
        'unicorn/prefer-includes': 'warn',
        'unicorn/prefer-module': 'off',
        'unicorn/prefer-node-protocol': 'off',
        'unicorn/prefer-number-properties': 'warn',
        'unicorn/prefer-object-from-entries': 'warn',
        'unicorn/prefer-query-selector': 'warn',
        'unicorn/prefer-set-has': 'warn',
        'unicorn/prefer-spread': 'warn',
        'unicorn/prefer-starts-ends-with': 'off',
        'unicorn/prefer-string-slice': 'warn',
        'unicorn/prefer-ternary': 'warn',
        'unicorn/prefer-text-content': 'off',
        'unicorn/prevent-abbreviations': [
            'warn',
            {
                allowList: {
                    assetsDir: true,
                    obj: true,
                    props: true,
                },
            },
        ],
        'unicorn/text-encoding-identifier-case': 'off',
        'use-isnan': 'warn',
        'valid-typeof': [ 'warn', { requireStringLiterals: false, },],
        'wrap-iife': [
            'warn',
            'inside',
            { functionPrototypeMethods: true, },
        ],
        'yield-star-spacing': [ 'warn', 'both' ],
        yoda: 'warn',
    }
    // Typescript
    , typescriptRules = {
        '@typescript-eslint/ban-ts-comment': [
            'warn',
            {
                minimumDescriptionLength: 18,
                'ts-check': 'allow-with-description',
                'ts-expect-error': 'allow-with-description',
                'ts-ignore': 'allow-with-description',
                'ts-nocheck': 'allow-with-description',
            },
        ],
        '@typescript-eslint/comma-dangle': [
            'warn',
            {
                arrays: 'always-multiline',
                enums: 'only-multiline',
                exports: 'always-multiline',
                functions: 'only-multiline',
                generics: 'only-multiline',
                imports: 'always-multiline',
                objects: 'always-multiline',
                tuples: 'only-multiline',
            },
        ],
        '@typescript-eslint/no-duplicate-imports': [ 'warn', { includeExports: true, },],
        '@typescript-eslint/no-explicit-any': [
            'warn',
            {
                fixToUnknown: true,
                ignoreRestArgs: true,
            },
        ],
        '@typescript-eslint/no-extra-semi': 'warn',
        '@typescript-eslint/no-unused-vars': [
            'warn',
            {
                args: 'after-used',
                argsIgnorePattern: '^_',
                caughtErrors: 'all',
                caughtErrorsIgnorePattern: '^_',
                ignoreRestSiblings: true,
                vars: 'all',
            },
        ],
        '@typescript-eslint/semi': [ 'warn', 'always' ],
        'import/order': [
            'warn',
            {
                alphabetize: { order: 'asc', },
                groups: [
                    'builtin', // Built-in types are first
                    'external',
                    'type',
                    'internal',
                    [ 'sibling', 'parent' ], // Then sibling and parent types. They can be mingled together
                    'index', // Then the index file
                    'object',
                ],
                'newlines-between': 'always-and-inside-groups',
                pathGroups: [
                    {
                        group: 'external',
                        pattern: 'ant-design-vue',
                    },
                    {
                        group: 'external',
                        pattern: 'ant-design-vue/**',
                    },
                    {
                        group: 'external',
                        pattern: '@ant-design',
                    },
                    {
                        group: 'external',
                        pattern: '@ant-design/**',
                    },
                    {
                        group: 'type',
                        pattern: '~/types**',
                        position: 'before',
                    },
                    {
                        group: 'internal',
                        pattern: '#**',
                        position: 'before'
                    },
                    {
                        group: 'internal',
                        pattern: 'pinia',
                        position: 'before'
                    },
                    {
                        group: 'internal',
                        pattern: '~~/**',
                    },
                    {
                        group: 'internal',
                        pattern: '~/**',
                        position: 'after'
                    },
                    {
                        group: 'object',
                        pattern: '~/costants**',
                        position: 'after'
                    },
                ],
                pathGroupsExcludedImportTypes: [
                    'ant-design-vue',
                    '@ant-design',
                    'pinia'
                ],
                warnOnUnassignedImports: true,
            },
        ],
        'no-duplicate-imports': 'off',
        'no-extra-semi': 'off',
        'no-unused-vars': 'off',
        semi: 'off',
    }
;

module.exports = {
    env: {
        browser: true,
        es2021: true,
        node: true,
    },
    extends: [
        'eslint:recommended',
        'plugin:jsdoc/recommended',
        'plugin:unicorn/recommended',
        'plugin:compat/recommended',
        'plugin:prettier/recommended',
    ],
    overrides: [
        {
            env: { jest: true, },
            extends: [ 'plugin:jest/style', 'plugin:jest/recommended' ],
            files: [
                './src/**/_test_/*.{j,t}s?(x)',
                './src/**/*.test.{j,t}s?(x)',
                './tests/*.test.{j,t}s?(x)'
            ],
            plugins: [ 'jest' ],
        },
        {
            extends: [
                'plugin:vue/strongly-recommended',
                'plugin:nuxt/recommended',
                'plugin:@typescript-eslint/recommended',
                '@nuxtjs/eslint-config-typescript',
            ],
            files: [ '*.vue', '*.ts' ],
            plugins: [
                'vue',
                'nuxt',
                '@typescript-eslint',
            ],
            rules: {
                ... sharedRules,
                ... typescriptRules,
                indent: 'off',
                'nuxt/no-this-in-fetch-data': 'warn',
                'sort-keys': 'off',
                'sort-keys-fix/sort-keys-fix': 'off',
                'vue/attribute-hyphenation': [ 'warn', 'always' ],
                'vue/attributes-order': [
                    'warn',
                    {
                        alphabetical: true,
                        order: [
                            'CONDITIONALS',
                            'LIST_RENDERING',
                            'RENDER_MODIFIERS',
                            'DEFINITION',
                            'TWO_WAY_BINDING',
                            'UNIQUE',
                            'GLOBAL',
                            'OTHER_ATTR',
                            'OTHER_DIRECTIVES',
                            'CONTENT',
                            'EVENTS',
                            'SLOT',
                        ],
                    },
                ],
                'vue/component-definition-name-casing': [ 'warn', 'kebab-case' ],
                'vue/component-name-in-template-casing': [
                    'warn',
                    'kebab-case',
                    { registeredComponentsOnly: false, },
                ],
                'vue/component-options-name-casing': [ 'warn', 'kebab-case' ],
                'vue/custom-event-name-casing': [
                    'warn',
                    'kebab-case',
                    { ignores: [ '/^[a-z]+(?:-[a-z]+)*:[a-z]+(?:-[a-z]+)*$/u' ] }
                ],
                'vue/html-closing-bracket-newline': [
                    'warn',
                    {
                        multiline: 'always',
                        singleline: 'never',
                    },
                ],
                'vue/html-closing-bracket-spacing': [
                    'warn',
                    {
                        endTag: 'never',
                        selfClosingTag: 'always',
                        startTag: 'never',
                    },
                ],
                'vue/html-end-tags': 'warn',
                'vue/html-indent': [ 'warn', 4 ],
                'vue/html-quotes': [ 'warn', 'double' ],
                'vue/html-self-closing': 'warn',
                'vue/max-attributes-per-line': [
                    'warn',
                    {
                        multiline: 1,
                        singleline: 2,
                    },
                ],
                'vue/multi-word-component-names': 'off',
                'vue/multiline-html-element-content-newline': [
                    'warn',
                    {
                        allowEmptyLines: true,
                        ignoreWhenEmpty: false,
                    },
                ],
                'vue/no-dupe-keys': 'warn',
                'vue/no-multiple-template-root': 'off',
                'vue/no-unused-components': 'warn',
                'vue/no-unused-vars': 'warn',
                'vue/no-use-v-if-with-v-for': [ 'warn', { allowUsingIterationVar: true, },],
                'vue/no-v-for-template-key': 'warn',
                'vue/no-v-for-template-key-on-child': 'off',
                'vue/no-v-html': 'off',
                'vue/no-v-model-argument': 'off',
                'vue/no-v-text-v-html-on-component': 'off',
                'vue/order-in-components': 'warn',
                'vue/require-default-prop': 'warn',
                'vue/require-name-property': 'warn',
                'vue/require-prop-types': 'warn',
                'vue/script-indent': [
                    'warn',
                    4,
                    {
                        baseIndent: 1,
                        switchCase: 1,
                    },
                ],
                'vue/singleline-html-element-content-newline': [
                    'warn',
                    {
                        ignoreWhenEmpty: false,
                        ignores: [ 'slot' ],
                    },
                ],
                'vue/sort-keys': [
                    'warn',
                    'asc',
                    {
                        caseSensitive: true,
                        ignoreGrandchildrenOf: [
                            'computed',
                            'directives',
                            'inject',
                            'props',
                            'watch'
                        ],
                        minKeys: 2,
                        natural: true,
                    }
                ],
                'vue/valid-next-tick': 'warn',
                'vue/valid-v-slot': [ 'warn', { allowModifiers: true, },],
            },
        },
        {
            extends: [ 'plugin:@typescript-eslint/recommended' ],
            files: [ '*.ts' ],
            parser: '@typescript-eslint/parser',
            plugins: [ '@typescript-eslint' ],
            rules: {
                ... sharedRules,
                ... typescriptRules,
            },
        },
    ],
    parserOptions: {
        ecmaFeatures: { jsx: true, },
        ecmaVersion: 'latest',
        parser: '@babel/eslint-parser',
        sourceType: 'module',
    },
    plugins: [
        'standard',
        'jsdoc',
        'unicorn',
        'compat',
        'promise',
        'import',
        'import-newlines',
        'sort-keys-fix',
        'eslint-comments',
        'prettier',
    ],
    reportUnusedDisableDirectives: true,
    root: true,
    rules: { ... sharedRules, },
    settings: {
        polyfills: [
            'Promise',
            'fetch',
            'Array.from',
        ],
    },
};