@newsteam/eslint-config 1.2.15 → 1.2.17

package/dist/rules/stylistic.js

@@ -0,0 +1,916 @@
+import stylistic from "@stylistic/eslint-plugin";
+import { INDENT_SPACES, MAXIMUM_LINE_LENGTH, } from "../settings.js";
+/*
+ * Stylistic rules for ESLint, works for both JavaScript and TypeScript.
+ *
+ * https://www.npmjs.com/package/@stylistic/eslint-plugin
+ */
+export const stylisticPluginConfig = {
+    plugins: {
+        "@stylistic": stylistic,
+    },
+    rules: {
+        /*
+         * Enforce linebreaks after opening and before closing array brackets
+         *
+         * https://eslint.style/rules/default/array-bracket-newline
+         */
+        "@stylistic/array-bracket-newline": [
+            "warn",
+            "consistent",
+        ],
+        /*
+         * Enforce consistent spacing inside array brackets
+         *
+         * https://eslint.style/rules/default/array-bracket-spacing
+         */
+        "@stylistic/array-bracket-spacing": "warn",
+        /*
+         * Enforce line breaks after each array element
+         *
+         * https://eslint.style/rules/default/array-element-newline
+         */
+        "@stylistic/array-element-newline": [
+            "warn",
+            "consistent",
+        ],
+        /*
+         * Require parentheses around arrow function arguments
+         *
+         * https://eslint.style/rules/default/arrow-parens
+         */
+        "@stylistic/arrow-parens": "warn",
+        /*
+         * Enforce consistent spacing before and after the arrow in arrow functions
+         *
+         * https://eslint.style/rules/default/arrow-spacing
+         */
+        "@stylistic/arrow-spacing": "warn",
+        /*
+         * Disallow or enforce spaces inside of blocks after opening block and
+         * before closing block
+         *
+         * https://eslint.style/rules/default/block-spacing
+         */
+        "@stylistic/block-spacing": "warn",
+        /*
+         * Enforce consistent brace style for blocks
+         *
+         * https://eslint.style/rules/default/brace-style
+         */
+        "@stylistic/brace-style": "warn",
+        /*
+         * Require or disallow trailing commas
+         *
+         * https://eslint.style/rules/default/comma-dangle
+         */
+        "@stylistic/comma-dangle": [
+            "warn",
+            {
+                arrays: "always-multiline",
+                enums: "always-multiline",
+                exports: "always-multiline",
+                functions: "always-multiline",
+                generics: "always-multiline",
+                imports: "always-multiline",
+                objects: "always-multiline",
+                tuples: "always-multiline",
+            },
+        ],
+        /*
+         * Enforce consistent spacing before and after commas
+         *
+         * https://eslint.style/rules/default/comma-spacing
+         */
+        "@stylistic/comma-spacing": "warn",
+        /*
+         * Enforce consistent comma style
+         *
+         * https://eslint.style/rules/default/comma-style
+         */
+        "@stylistic/comma-style": "warn",
+        /*
+         * Enforce consistent spacing inside computed property brackets
+         *
+         * https://eslint.style/rules/default/computed-property-spacing
+         */
+        "@stylistic/computed-property-spacing": "warn",
+        /*
+         *
+         *
+         * https://eslint.style/rules/default/curly-newline
+         */
+        "@stylistic/curly-newline": [
+            "warn",
+            {
+                ArrowFunctionExpression: "always",
+                BlockStatement: "always",
+                ClassBody: "always",
+                DoWhileStatement: "always",
+                ForInStatement: "always",
+                ForOfStatement: "always",
+                ForStatement: "always",
+                FunctionDeclaration: "always",
+                FunctionExpression: "always",
+                IfStatementAlternative: "always",
+                IfStatementConsequent: "always",
+                Property: "always",
+                StaticBlock: "always",
+                SwitchCase: "always",
+                SwitchStatement: "always",
+                TryStatementBlock: {
+                    consistent: true,
+                    minElements: 1,
+                    multiline: true,
+                },
+                TryStatementFinalizer: {
+                    consistent: true,
+                    minElements: 1,
+                    multiline: true,
+                },
+                TryStatementHandler: {
+                    consistent: true,
+                    minElements: 1,
+                    multiline: true,
+                },
+                TSModuleBlock: "always",
+                WhileStatement: "always",
+                WithStatement: "always",
+            },
+        ],
+        /*
+         * Enforce consistent newlines before and after dots
+         *
+         * https://eslint.style/rules/default/dot-location
+         */
+        "@stylistic/dot-location": [
+            "warn",
+            "property",
+        ],
+        /*
+         * Require or disallow newline at the end of files
+         *
+         * https://eslint.style/rules/default/eol-last
+         */
+        "@stylistic/eol-last": "warn",
+        /*
+         * Enforce consistent line break styles for JSX props. (experimental)
+         *
+         * https://eslint.style/rules/default/jsx-props-style
+         */
+        "@stylistic/exp-jsx-props-style": [
+            "warn",
+            {
+                multiLine: {
+                    maxItemsPerLine: 1,
+                    minItems: 0,
+                },
+                singleLine: {
+                    maxItems: 1,
+                },
+            },
+        ],
+        /*
+         * Enforce consistent spacing and line break styles inside brackets. (experimental)
+         *
+         * https://eslint.style/rules/default/list-style
+         */
+        "@stylistic/exp-list-style": [
+            "warn",
+            {
+                multiLine: {
+                    minItems: 0,
+                },
+                overrides: {
+                    "{}": { singleLine: { spacing: "always" } },
+                    TSTypeLiteral: {
+                        singleLine: {
+                            maxItems: 1,
+                            spacing: "always",
+                        },
+                    },
+                },
+                singleLine: {
+                    maxItems: Number.POSITIVE_INFINITY,
+                    spacing: "never",
+                },
+            },
+        ],
+        /*
+         * Enforce line breaks between arguments of a function call
+         *
+         * https://eslint.style/rules/default/function-call-argument-newline
+         */
+        "@stylistic/function-call-argument-newline": [
+            "warn",
+            "consistent",
+        ],
+        /*
+         * Require or disallow spacing between function identifiers and their
+         * invocations
+         *
+         * https://eslint.style/rules/default/function-call-spacing
+         */
+        "@stylistic/function-call-spacing": "warn",
+        /*
+         * Enforce consistent line breaks inside function parentheses
+         *
+         * https://eslint.style/rules/default/function-paren-newline
+         */
+        "@stylistic/function-paren-newline": ["warn", "consistent"],
+        /*
+         * Enforce consistent spacing around * operators in generator functions
+         *
+         * https://eslint.style/rules/default/generator-star-spacing
+         */
+        "@stylistic/generator-star-spacing": "warn",
+        /*
+         * Enforce the location of arrow function bodies
+         *
+         * https://eslint.style/rules/default/implicit-arrow-linebreak
+         */
+        "@stylistic/implicit-arrow-linebreak": "warn",
+        /*
+         * Enforce consistent indentation
+         *
+         * https://eslint.style/rules/default/indent
+         */
+        "@stylistic/indent": [
+            "warn",
+            INDENT_SPACES,
+            {
+                MemberExpression: 0,
+                SwitchCase: 1,
+            },
+        ],
+        /*
+         * Enforce consistent indentation
+         *
+         * https://eslint.style/rules/default/indent-binary-ops
+         */
+        "@stylistic/indent-binary-ops": [
+            "warn",
+            INDENT_SPACES,
+        ],
+        /*
+         * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions.
+         *
+         * https://eslint.style/rules/default/jsx-child-element-spacing
+         */
+        "@stylistic/jsx-child-element-spacing": "warn",
+        /*
+         * Validate closing bracket location in JSX (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-closing-bracket-location
+         */
+        "@stylistic/jsx-closing-bracket-location": "warn",
+        /*
+         * Validate closing tag location in JSX (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-closing-tag-location
+         */
+        "@stylistic/jsx-closing-tag-location": "warn",
+        /*
+         * Enforce curly braces or disallow unnecessary curly braces in JSX
+         *
+         * This conflicts with react/jsx-no-literals. Leaving off for now.
+         *
+         * https://eslint.style/rules/default/jsx-curly-brace-presence
+         */
+        "@stylistic/jsx-curly-brace-presence": "off",
+        /*
+         * Enforce linebreaks in curly braces in JSX attributes and expressions. (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-curly-newline
+         */
+        "@stylistic/jsx-curly-newline": ["warn", "consistent"],
+        /*
+         * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-curly-spacing
+         */
+        "@stylistic/jsx-curly-spacing": [
+            "warn",
+            {
+                children: { when: "always" },
+                when: "always",
+            },
+        ],
+        /*
+         * Enforce or disallow spaces around equal signs in JSX attributes (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-equals-spacing
+         */
+        "@stylistic/jsx-equals-spacing": "warn",
+        /*
+         * Enforce position of the first prop in JSX (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-first-prop-new-line
+         */
+        "@stylistic/jsx-first-prop-new-line": "warn",
+        /*
+         * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
+         *
+         * https://eslint.style/rules/default/jsx-function-call-newline
+         */
+        "@stylistic/jsx-function-call-newline": ["warn", "multiline"],
+        /*
+         * Validate props indentation in JSX (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-indent-props
+         */
+        "@stylistic/jsx-indent-props": "warn",
+        /*
+         * Limit maximum of props on a single line in JSX (fixable)
+         *
+         * This is off for now because it causes --fix to get into a fight with
+         * 'react/jsx-indent', causing an infinite loop of fixing
+         *
+         * https://eslint.style/rules/default/jsx-max-props-per-line
+         */
+        "@stylistic/jsx-max-props-per-line": [
+            "warn",
+            { maximum: 1 },
+        ],
+        /*
+         * Enforce a new line after jsx elements and expressions (fixable)
+         *
+         * This is off for now because it this would make too much empty space
+         *
+         * https://eslint.style/rules/default/jsx-newline
+         */
+        "@stylistic/jsx-newline": "off",
+        /*
+         * Limit to one expression per line in JSX
+         *
+         * https://eslint.style/rules/default/jsx-one-expression-per-line
+         */
+        "@stylistic/jsx-one-expression-per-line": "warn",
+        /*
+         * Enforces coding style that user-defined JSX components are defined and referenced in PascalCase.
+         *
+         * https://eslint.style/rules/default/jsx-pascal-case
+         */
+        "@stylistic/jsx-pascal-case": "warn",
+        /*
+         * Enforce the consistent use of either double or single quotes in JSX attributes
+         *
+         * https://eslint.style/rules/default/jsx-quotes
+         */
+        "@stylistic/jsx-quotes": "warn",
+        /*
+         * Prevent extra closing tags for components without children (fixable)
+         *
+         * https://eslint.style/rules/default/self-closing-comp
+         */
+        "@stylistic/jsx-self-closing-comp": "warn",
+        /*
+         * Enforce props alphabetical sorting (fixable)
+         *
+         * Handled by eslint-plugin-perfectionst
+         *
+         * https://eslint.style/rules/default/jsx-sort-props
+         */
+        "@stylistic/jsx-sort-props": [
+            "off",
+            {
+                ignoreCase: true,
+            },
+        ],
+        /*
+         * Validate whitespace in and around the JSX opening and closing brackets (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-tag-spacing
+         */
+        "@stylistic/jsx-tag-spacing": "warn",
+        /*
+         * Prevent missing parentheses around multilines JSX (fixable)
+         *
+         * https://eslint.style/rules/default/jsx-wrap-multilines
+         */
+        "@stylistic/jsx-wrap-multilines": "warn",
+        /*
+         * Enforce consistent spacing between keys and values in object literal properties
+         *
+         * https://eslint.style/rules/default/key-spacing
+         */
+        "@stylistic/key-spacing": [
+            "warn",
+            {
+                afterColon: true,
+                beforeColon: false,
+                mode: "strict",
+            },
+        ],
+        /*
+         * Enforce consistent spacing before and after keywords
+         *
+         * https://eslint.style/rules/default/keyword-spacing
+         */
+        "@stylistic/keyword-spacing": [
+            "warn",
+            {
+                after: true,
+                before: true,
+                overrides: {
+                    case: {
+                        before: false,
+                    },
+                    catch: {
+                        after: false,
+                        before: false,
+                    },
+                    class: {
+                        after: false,
+                        before: false,
+                    },
+                    const: {
+                        before: false,
+                    },
+                    else: {
+                        after: false,
+                        before: false,
+                    },
+                    export: {
+                        before: false,
+                    },
+                    finally: {
+                        after: false,
+                        before: false,
+                    },
+                    for: {
+                        after: false,
+                    },
+                    if: {
+                        after: false,
+                    },
+                    import: {
+                        before: false,
+                    },
+                    let: {
+                        before: false,
+                    },
+                    return: {
+                        before: false,
+                    },
+                    switch: {
+                        after: false,
+                    },
+                    this: {
+                        after: false,
+                    },
+                    try: {
+                        after: false,
+                    },
+                    while: {
+                        after: false,
+                    },
+                },
+            },
+        ],
+        /*
+         * Line comments can be positioned above or beside code. This rule helps teams maintain a consistent style.
+         *
+         * https://eslint.style/rules/default/line-comment-position
+         */
+        "@stylistic/line-comment-position": "warn",
+        /*
+         * Enforce consistent linebreak style
+         *
+         * https://eslint.style/rules/default/linebreak-style
+         */
+        "@stylistic/linebreak-style": "warn",
+        /*
+         * Require empty lines around comments
+         *
+         * https://eslint.style/rules/default/lines-around-comment
+         */
+        "@stylistic/lines-around-comment": "warn",
+        /*
+         * Require or disallow an empty line between class members
+         *
+         * https://eslint.style/rules/default/lines-between-class-members
+         */
+        "@stylistic/lines-between-class-members": [
+            "warn",
+            "always",
+            {
+                exceptAfterSingleLine: true,
+            },
+        ],
+        /*
+         * Enforce a maximum line length
+         *
+         * https://eslint.style/rules/default/max-len
+         */
+        "@stylistic/max-len": [
+            "warn",
+            {
+                code: MAXIMUM_LINE_LENGTH,
+                ignoreComments: true,
+            },
+        ],
+        /*
+         * Enforce a maximum number of statements allowed per line
+         *
+         * https://eslint.style/rules/default/max-statements-per-line
+         */
+        "@stylistic/max-statements-per-line": [
+            "warn",
+            {
+                max: 1,
+            },
+        ],
+        /*
+         * Require a specific member delimiter style for interfaces and type literals
+         *
+         * https://eslint.style/rules/default/member-delimiter-style
+         */
+        "@stylistic/member-delimiter-style": "warn",
+        /*
+         * Many style guides require a particular style for comments that span multiple lines.
+         * For example, some style guides prefer the use of a single block comment for multiline
+         * comments, whereas other style guides prefer consecutive line comments.
+         *
+         * Off because it's annoying
+         *
+         * https://eslint.style/rules/default/multiline-comment-style
+         */
+        "@stylistic/multiline-comment-style": "off",
+        /*
+         * Enforce newlines between operands of ternary expressions
+         *
+         * https://eslint.style/rules/default/multiline-ternary
+         */
+        "@stylistic/multiline-ternary": ["warn", "always-multiline"],
+        /*
+         * Require parentheses when invoking a constructor with no arguments
+         *
+         * https://eslint.style/rules/default/new-parens
+         */
+        "@stylistic/new-parens": "warn",
+        /*
+         * Require a newline after each call in a method chain
+         *
+         * https://eslint.style/rules/default/newline-per-chained-call
+         */
+        "@stylistic/newline-per-chained-call": [
+            "warn",
+            {
+                ignoreChainWithDepth: 3,
+            },
+        ],
+        /*
+         * Disallow arrow functions where they could be confused with comparisons
+         *
+         * Off for now because I believe in myself
+         *
+         * https://eslint.style/rules/default/no-confusing-arrow
+         */
+        "@stylistic/no-confusing-arrow": "off",
+        /*
+         * Disallow unnecessary parentheses
+         *
+         * https://eslint.style/rules/default/no-extra-parens
+         */
+        "@stylistic/no-extra-parens": [
+            "warn",
+            "all",
+            {
+                ignoreJSX: "multi-line",
+                nestedConditionalExpressions: false,
+                ternaryOperandBinaryExpressions: false,
+            },
+        ],
+        /*
+         * Disallow unnecessary semicolons
+         *
+         * https://eslint.style/rules/default/no-extra-semi
+         */
+        "@stylistic/no-extra-semi": "warn",
+        /*
+         * Disallow leading or trailing decimal points in numeric literals
+         *
+         * https://eslint.style/rules/default/no-floating-decimal
+         */
+        "@stylistic/no-floating-decimal": "warn",
+        /*
+         * Disallow mixed binary operators
+         *
+         * Using mixed operators is chilled
+         *
+         * https://eslint.style/rules/default/no-mixed-operators
+         */
+        "@stylistic/no-mixed-operators": "off",
+        /*
+         * Disallow mixed spaces and tabs for indentation
+         *
+         * https://eslint.style/rules/default/no-mixed-spaces-and-tabs
+         */
+        "@stylistic/no-mixed-spaces-and-tabs": "warn",
+        /*
+         * Disallow multiple spaces
+         *
+         * https://eslint.style/rules/default/no-multi-spaces
+         */
+        "@stylistic/no-multi-spaces": "warn",
+        /*
+         * Disallow multiple empty lines
+         *
+         * https://eslint.style/rules/default/no-multiple-empty-lines
+         */
+        "@stylistic/no-multiple-empty-lines": "warn",
+        /*
+         * Disallow all tabs
+         *
+         * https://eslint.style/rules/default/no-tabs
+         */
+        "@stylistic/no-tabs": "warn",
+        /*
+         * Disallow trailing whitespace at the end of lines
+         *
+         * https://eslint.style/rules/default/no-trailing-spaces
+         */
+        "@stylistic/no-trailing-spaces": "warn",
+        /*
+         * Disallow whitespace before properties
+         *
+         * https://eslint.style/rules/default/no-whitespace-before-property
+         */
+        "@stylistic/no-whitespace-before-property": "warn",
+        /*
+         * Enforce the location of single-line statements
+         *
+         * https://eslint.style/rules/default/nonblock-statement-body-position
+         */
+        "@stylistic/nonblock-statement-body-position": "warn",
+        /*
+         * Enforce consistent line breaks inside braces
+         *
+         * https://eslint.style/rules/default/object-curly-newline
+         */
+        "@stylistic/object-curly-newline": [
+            "warn",
+            {
+                ExportDeclaration: {
+                    consistent: true,
+                    minProperties: 2,
+                    multiline: true,
+                },
+                ImportDeclaration: {
+                    consistent: true,
+                    minProperties: 2,
+                    multiline: true,
+                },
+                ObjectExpression: {
+                    consistent: true,
+                    minProperties: 2,
+                    multiline: true,
+                },
+                ObjectPattern: {
+                    consistent: true,
+                    minProperties: 2,
+                    multiline: true,
+                },
+            },
+        ],
+        /*
+         * Enforce consistent spacing inside braces
+         *
+         * https://eslint.style/rules/default/object-curly-spacing
+         */
+        "@stylistic/object-curly-spacing": ["warn", "always"],
+        /*
+         * Enforce placing object properties on separate lines
+         *
+         * https://eslint.style/rules/default/object-property-newline
+         */
+        "@stylistic/object-property-newline": [
+            "warn",
+            {
+                allowAllPropertiesOnSameLine: false,
+            },
+        ],
+        /*
+         * Require or disallow newlines around variable declarations
+         *
+         * https://eslint.style/rules/default/one-var-declaration-per-line
+         */
+        "@stylistic/one-var-declaration-per-line": "warn",
+        /*
+         * Enforce consistent linebreak style for operators
+         *
+         * https://eslint.style/rules/default/operator-linebreak
+         */
+        "@stylistic/operator-linebreak": [
+            "warn",
+            "before",
+            {
+                overrides: { "=": "after" },
+            },
+        ],
+        /*
+         * Require or disallow padding within blocks
+         *
+         * https://eslint.style/rules/default/padded-blocks
+         */
+        "@stylistic/padded-blocks": [
+            "warn",
+            {
+                blocks: "always",
+                classes: "always",
+                switches: "always",
+            },
+            {
+                allowSingleLineBlocks: true,
+            },
+        ],
+        /*
+         * Require or disallow padding lines between statements
+         *
+         * https://eslint.style/rules/default/padding-line-between-statements
+         */
+        "@stylistic/padding-line-between-statements": [
+            "warn",
+            {
+                blankLine: "always",
+                next: [
+                    "const",
+                    "directive",
+                    "export",
+                    "let",
+                    "multiline-block-like",
+                    "return",
+                    "var",
+                ],
+                prev: [
+                    "directive",
+                    "multiline-block-like",
+                    "return",
+                ],
+            },
+            {
+                blankLine: "always",
+                next: "if",
+                prev: "*",
+            },
+            {
+                blankLine: "always",
+                next: "return",
+                prev: "*",
+            },
+        ],
+        /*
+         * Require quotes around object literal property names
+         *
+         * https://eslint.style/rules/default/quote-props
+         */
+        "@stylistic/quote-props": ["warn", "as-needed"],
+        /*
+         * Enforce the consistent use of either backticks, double, or single quotes
+         *
+         * https://eslint.style/rules/default/quotes
+         */
+        "@stylistic/quotes": "warn",
+        /*
+         * Enforce spacing between rest and spread operators and their expressions
+         *
+         * https://eslint.style/rules/default/rest-spread-spacing
+         */
+        "@stylistic/rest-spread-spacing": "warn",
+        /*
+         * Require or disallow semicolons instead of ASI
+         *
+         * https://eslint.style/rules/default/semi
+         */
+        "@stylistic/semi": "warn",
+        /*
+         * Enforce consistent spacing before and after semicolons
+         *
+         * https://eslint.style/rules/default/semi-spacing
+         */
+        "@stylistic/semi-spacing": "warn",
+        /*
+         * Enforce location of semicolons
+         *
+         * https://eslint.style/rules/default/semi-style
+         */
+        "@stylistic/semi-style": [
+            "warn",
+            "last",
+        ],
+        /*
+         * Enforce consistent spacing before blocks
+         *
+         * https://eslint.style/rules/default/space-before-blocks
+         */
+        "@stylistic/space-before-blocks": [
+            "warn",
+            {
+                classes: "never",
+                functions: "never",
+                keywords: "never",
+            },
+        ],
+        /*
+         * Enforce consistent spacing before function definition opening parenthesis
+         *
+         * https://eslint.style/rules/default/space-before-function-paren
+         */
+        "@stylistic/space-before-function-paren": [
+            "warn",
+            {
+                anonymous: "never",
+                asyncArrow: "always",
+                named: "never",
+            },
+        ],
+        /*
+         * Enforce consistent spacing inside parentheses
+         *
+         * https://eslint.style/rules/default/space-in-parens
+         */
+        "@stylistic/space-in-parens": ["warn", "never"],
+        /*
+         * Require spacing around infix operators
+         *
+         * https://eslint.style/rules/default/space-infix-ops
+         */
+        "@stylistic/space-infix-ops": "warn",
+        /*
+         * Enforce consistent spacing before or after unary operators
+         *
+         * https://eslint.style/rules/default/space-unary-ops
+         */
+        "@stylistic/space-unary-ops": "warn",
+        /*
+         * Enforce consistent spacing after the // or /* in a comment
+         *
+         * https://eslint.style/rules/default/spaced-comment
+         */
+        "@stylistic/spaced-comment": "warn",
+        /*
+         * Enforce spacing around colons of switch statements
+         *
+         * https://eslint.style/rules/default/switch-colon-spacing
+         */
+        "@stylistic/switch-colon-spacing": [
+            "warn",
+            {
+                after: false,
+                before: true,
+            },
+        ],
+        /*
+         * Require or disallow spacing around embedded expressions of template strings
+         *
+         * https://eslint.style/rules/default/template-curly-spacing
+         */
+        "@stylistic/template-curly-spacing": [
+            "warn",
+            "always",
+        ],
+        /*
+         * Require or disallow spacing between template tags and their literals
+         *
+         * https://eslint.style/rules/default/template-tag-spacing
+         */
+        "@stylistic/template-tag-spacing": "warn",
+        /*
+         * Require consistent spacing around type annotations
+         *
+         * https://eslint.style/rules/default/type-annotation-spacing
+         */
+        "@stylistic/type-annotation-spacing": "warn",
+        /*
+         * Enforces consistent spacing inside TypeScript type generics.
+         *
+         * https://eslint.style/rules/default/type-generic-spacing
+         */
+        "@stylistic/type-generic-spacing": "warn",
+        /*
+         * Expect space before the type declaration in the named tuple.
+         *
+         * https://eslint.style/rules/default/type-named-tuple-spacing
+         */
+        "@stylistic/type-named-tuple-spacing": "warn",
+        /*
+         * Require parentheses around immediate function invocations
+         *
+         * https://eslint.style/rules/default/wrap-iife
+         */
+        "@stylistic/wrap-iife": "warn",
+        /*
+         * Require parenthesis around regex literals
+         *
+         * https://eslint.style/rules/default/wrap-regex
+         */
+        "@stylistic/wrap-regex": "warn",
+        /*
+         * Require or disallow spacing around the * in yield* Expressions
+         *
+         * https://eslint.style/rules/default/yield-star-spacing
+         */
+        "@stylistic/yield-star-spacing": "warn",
+    },
+};