@prowise/eslint-config-linting-rules 0.0.1

package/src/rules/plugin-typescript-rules.js

@@ -0,0 +1,928 @@
+const { rules: baseRules } = require("./base-rules");
+const { rules: baseImportsRules } = require("./plugin-import-rules");
+
+module.exports = {
+    /*
+     * ✅ recommended
+     * 🔒 strict
+     * 🔧 fixable
+     * 💡 has suggestion
+     * 💭 requires type information
+     */
+
+    plugins: ["@typescript-eslint"],
+    parser: "@typescript-eslint/parser",
+
+    settings: {
+        // Apply special parsing for TypeScript files
+        "import/parsers": {
+            "@typescript-eslint/parser": [".ts", ".tsx", ".d.ts"],
+        },
+
+        // Append "ts" extensions to Airbnb "import/resolver" setting
+        "import/resolver": {
+            node: { extensions: [".mjs", ".js", ".json", ".ts", ".d.ts"] },
+        },
+
+        // Append "ts" extensions to Airbnb "import/extensions" setting
+        "import/extensions": [".js", ".mjs", ".jsx", ".ts", ".tsx", ".d.ts"],
+
+        // Resolve type definition packages
+        "import/external-module-folders": ["node_modules", "node_modules/@types"],
+    },
+
+    rules: {
+        /**
+         * Require that member overloads be consecutive ✅
+         * https://typescript-eslint.io/rules/adjacent-overload-signatures.
+         */
+        "@typescript-eslint/adjacent-overload-signatures": "error",
+
+        /**
+         * Require using either T[] or Array<T> for arrays 🔒 🔧
+         * https://typescript-eslint.io/rules/array-type.
+         */
+        "@typescript-eslint/array-type": ["error", { default: "array" }],
+
+        /**
+         * Disallow awaiting a value that is not a Thenable ✅  💭
+         * https://typescript-eslint.io/rules/await-thenable.
+         */
+        "@typescript-eslint/await-thenable": "error",
+
+        /**
+         * Disallow @ts-<directive> comments or require descriptions after directive ✅
+         * https://typescript-eslint.io/rules/ban-ts-comment.
+         */
+        "@typescript-eslint/ban-ts-comment": [
+            "warn",
+            {
+                "ts-expect-error": "allow-with-description",
+                "ts-ignore": "allow-with-description",
+                "ts-nocheck": "allow-with-description",
+                "ts-check": "allow-with-description",
+                minimumDescriptionLength: 3,
+            },
+        ],
+
+        /**
+         * Disallow // tslint:<rule-flag> comments 🔒 🔧
+         * https://typescript-eslint.io/rules/ban-tslint-comment.
+         */
+        "@typescript-eslint/ban-tslint-comment": "warn",
+
+        /**
+         * Disallow certain types ✅ 🔧
+         * https://typescript-eslint.io/rules/ban-types.
+         */
+        "@typescript-eslint/ban-types": [
+            "error",
+            {
+                types: {
+                    Object: {
+                        message: "Avoid using the `Object` type. Did you mean `object`?",
+                    },
+                    Function: {
+                        message: "Avoid using the `Function` type. Prefer a specific function type, like `() => void`.",
+                    },
+                    Boolean: {
+                        message: "Avoid using the `Boolean` type. Did you mean `boolean`?",
+                    },
+                    Number: {
+                        message: "Avoid using the `Number` type. Did you mean `number`?",
+                    },
+                    String: {
+                        message: "Avoid using the `String` type. Did you mean `string`?",
+                    },
+                    Symbol: {
+                        message: "Avoid using the `Symbol` type. Did you mean `symbol`?",
+                    },
+                },
+            },
+        ],
+
+        /**
+         * Enforce that literals on classes are exposed in a consistent style 🔒 🔧
+         * https://typescript-eslint.io/rules/class-litiral-property-style.
+         */
+        "@typescript-eslint/class-literal-property-style": "warn",
+
+        /**
+         * Require or disallow trailing commas.🔧
+         * https://typescript-eslint.io/rules/comma-dangle.
+         */
+        "comma-dangle": "off",
+        "@typescript-eslint/comma-dangle": [
+            baseRules["comma-dangle"][0],
+            {
+                ...baseRules["comma-dangle"][1],
+                enums: baseRules["comma-dangle"][1].arrays,
+                generics: baseRules["comma-dangle"][1].arrays,
+                tuples: baseRules["comma-dangle"][1].arrays,
+            },
+        ],
+
+        /**
+         * Enforce specifying generic type arguments on type annotation or constructor name of a constructor call 🔒 🔧
+         * https://typescript-eslint.io/rules/consistent-generic-constructors.
+         */
+        "@typescript-eslint/consistent-generic-constructors": "warn",
+
+        /**
+         * Require or disallow the Record type 🔒 🔧
+         * https://typescript-eslint.io/rules/consistent-indexed-oject-style.
+         */
+        "@typescript-eslint/consistent-indexed-object-style": "warn",
+
+        /**
+         * Enforce consistent usage of type assertions 🔒
+         * https://typescript-eslint.io/rules/consistent-type-assertions.
+         */
+        "@typescript-eslint/consistent-type-assertions": "error",
+
+        /**
+         * Enforce type definitions to consistently use either interface or type 🔒 🔧
+         * https://typescript-eslint.io/rules/consistent-type-definitions.
+         */
+        "@typescript-eslint/consistent-type-definitions": "warn",
+
+        /**
+         * Enforce consistent usage of type exports 🔧 💭
+         * https://typescript-eslint.io/rules/consistend-type-exports.
+         */
+        "@typescript-eslint/consistent-type-exports": "warn",
+
+        /**
+         * Enforce consistent usage of type imports  🔧
+         * https://typescript-eslint.io/rules/consistent-type-imports.
+         */
+        "@typescript-eslint/consistent-type-imports": ["warn", { prefer: "no-type-imports" }],
+
+        /**
+         * Enforce default parameters to be last.
+         * Https://typescript-eslint.io/rules/default-param-last.
+         */
+        "default-param-last": "off",
+        "@typescript-eslint/default-param-last": baseRules["default-param-last"],
+
+        /**
+         * Enforce dot notation whenever possible.
+         * Https://typescript-eslint.io/rules/dot-notation.
+         */
+        "dot-notation": "off",
+        "@typescript-eslint/dot-notation": baseRules["dot-notation"],
+
+        /**
+         * Require explicit return types on functions and class methods
+         * https://typescript-eslint.io/rules/explicit-function-return.
+         */
+        "@typescript-eslint/explicit-function-return-type": "warn",
+
+        /**
+         * Require explicit accessibility modifiers on class properties and methods 🔧 💡
+         * https://typescript-eslint.io/rules/explicit-member-accessibility.
+         */
+        "@typescript-eslint/explicit-member-accessibility": "error",
+
+        /**
+         * Require explicit return and argument types on exported functions" and classes" public class methods
+         * https://typescript-eslint.io/rules/explicit-module-boundary-types.
+         */
+        "@typescript-eslint/explicit-module-boundary-types": "warn",
+
+        /**
+         * Require or disallow initialization in variable declarations
+         * https://typescript-eslint.io/rules/init-declarations.
+         */
+        "init-declarations": "off",
+        "@typescript-eslint/init-declarations": baseRules["init-declarations"],
+
+        /**
+         * Require a specific member delimiter style for interfaces and type literals 🔧
+         * https://typescript-eslint.io/rules/member-delimiter-style.
+         */
+        "@typescript-eslint/member-delimiter-style": "warn",
+
+        /**
+         * Require a consistent member declaration order
+         * https://typescript-eslint.io/rules/member-ordering.
+         */
+        "@typescript-eslint/member-ordering": "off",
+
+        /**
+         * Enforce using a particular method signature syntax 🔧
+         * https://typescript-eslint.io/rules/method-signature-style.
+         */
+        "@typescript-eslint/method-signature-style": "warn",
+
+        /**
+         * Enforce naming conventions for everything across a codebase 💭
+         * https://typescript-eslint.io/rules/naming-convention.
+         */
+        camelcase: "off", // The `@typescript-eslint/naming-convention` rule allows `leadingUnderscore` and `trailingUnderscore` settings. However, the existing `no-underscore-dangle` rule already takes care of this.
+        "@typescript-eslint/naming-convention": [
+            "error",
+            // Allow camelCase variables (23.2), PascalCase variables (23.8), and UPPER_CASE variables (23.10)
+            {
+                selector: "variable",
+                format: ["camelCase", "PascalCase", "UPPER_CASE"],
+            },
+            // Allow camelCase functions (23.2), and PascalCase functions (23.8)
+            {
+                selector: "function",
+                format: ["camelCase", "PascalCase"],
+            },
+            // Airbnb recommends PascalCase for classes (23.3), and although Airbnb does not make TypeScript
+            // recommendations we are assuming this rule would similarly apply to anything "type like",
+            // including interfaces, type aliases, and enums
+            {
+                selector: "typeLike",
+                format: ["PascalCase"],
+            },
+        ],
+
+        /**
+         * Disallow generic Array constructors.✅
+         * https://typescript-eslint.io/rules/no-array-constructor.
+         */
+        "no-array-constructor": "off",
+        "@typescript-eslint/no-array-constructor": baseRules["no-array-constructor"],
+
+        /**
+         * Require .toString() to only be called on objects which provide useful information when stringified 🔒 💭
+         * https://typescript-eslint.io/rules/no-base-to-string.
+         */
+        "@typescript-eslint/no-base-to-string": "warn",
+
+        /**
+         * Disallow non-null assertion in locations that may be confusing 🔒 🔧 💡
+         * https://typescript-eslint.io/rules/no-confusing-non-null-assertion.
+         */
+        "@typescript-eslint/no-confusing-non-null-assertion": "warn",
+
+        /**
+         * Require expressions of type void to appear in statement position 🔧 💡 💭
+         * https://typescript-eslint.io/rules/no-confusing-void-expression.
+         */
+        "@typescript-eslint/no-confusing-void-expression": "warn",
+
+        /**
+         * Disallow duplicate class members.
+         * Https://typescript-eslint.io/rules/no-dupe-class-members.
+         */
+        "no-dupe-class-members": "off",
+        "@typescript-eslint/no-dupe-class-members": baseRules["no-dupe-class-members"],
+
+        /**
+         * Disallow duplicate enum member values 🔒
+         * https://typescript-eslint.io/rules/no-duplicate-enum-values.
+         */
+        "@typescript-eslint/no-duplicate-enum-values": "warn",
+
+        /**
+         * Disallow using the delete operator on computed key expressions 🔒 🔧
+         * https://typescript-eslint.io/rules/no-dynamic-delete.
+         */
+        "@typescript-eslint/no-dynamic-delete": "warn",
+
+        /**
+         * Disallow the declaration of empty functions ✅
+         * https://typescript-eslint.io/rules/no-empty-function.
+         */
+        "no-empty-function": "off",
+        "@typescript-eslint/no-empty-function": baseRules["no-empty-function"],
+
+        /**
+         * Disallow the declaration of empty interfaces ✅  🔧 💡
+         * https://typescript-eslint.io/rules/no-empty-interface.
+         */
+        "@typescript-eslint/no-empty-interface": ["error", { allowSingleExtends: false }],
+
+        /**
+         * Disallow the any type ✅ 🔧 💡
+         * https://typescript-eslint.io/rules/no-explicit-any.
+         */
+        "@typescript-eslint/no-explicit-any": "off",
+
+        /**
+         * Disallow extra non-null assertion ✅ 🔧
+         * https://typescript-eslint.io/rules/no-extra-non-null-assertion.
+         */
+        "@typescript-eslint/no-extra-non-null-assertion": "error",
+
+        /**
+         * Disallow unnecessary parentheses.🔧
+         * https://typescript-eslint.io/rules/no-extra-parens.
+         */
+        "no-extra-parens": "off",
+        "@typescript-eslint/no-extra-parens": baseRules["no-extra-parens"],
+
+        /**
+         * Disallow unnecessary semicolons.✅ 🔧
+         * https://typescript-eslint.io/rules/no-extra-semi.
+         */
+        "no-extra-semi": "off",
+        "@typescript-eslint/no-extra-semi": baseRules["no-extra-semi"],
+
+        /**
+         * Disallow classes used as namespaces 🔒
+         * https://typescript-eslint.io/rules/no-extraneous-class.
+         */
+        "@typescript-eslint/no-extraneous-class": "warn",
+
+        /**
+         * Require Promise-like statements to be handled appropriately ✅ 💡 💭
+         * https://typescript-eslint.io/rules/no-floating-promises.
+         */
+        "@typescript-eslint/no-floating-promises": "error",
+
+        /**
+         * Disallow iterating over an array with a for-in loop ✅  💭
+         * https://typescript-eslint.io/rules/no-for-in-array.
+         */
+        "@typescript-eslint/no-for-in-array": "error",
+
+        /**
+         * Disallow the use of eval()-like methods. ✅ 💭
+         * https://typescript-eslint.io/rules/no-implied-eval.
+         */
+        "no-implied-eval": "off",
+        "no-new-function": "off",
+        "@typescript-eslint/no-implied-eval": baseRules["no-implied-eval"],
+
+        /**
+         * Disallow explicit type declarations for variables or parameters initialized to a number,
+         * string, or boolean ✅ 🔧
+         * https://typescript-eslint.io/rules/no-inferrable-types.
+         */
+        "@typescript-eslint/no-inferrable-types": ["error", { ignoreParameters: false, ignoreProperties: false }],
+
+        /**
+         * Disallow this keywords outside of classes or class-like objects.
+         * Https://typescript-eslint.io/rules/no-invalid-this.
+         */
+        "no-invalid-this": "off",
+        "@typescript-eslint/no-invalid-this": baseRules["no-invalid-this"],
+
+        /**
+         * Disallow void type outside of generic or return types 🔒
+         * https://typescript-eslint.io/rules/no-invalid-void-type.
+         */
+        "@typescript-eslint/no-invalid-void-type": "off",
+
+        /**
+         * Disallow function declarations that contain unsafe references inside loop statements.
+         * Https://typescript-eslint.io/rules/no-loop-func.
+         */
+        "no-loop-func": "off",
+        "@typescript-eslint/no-loop-func": baseRules["no-loop-func"],
+
+        /**
+         * Disallow literal numbers that lose precision. ✅
+         * https://typescript-eslint.io/rules/no-loss-of-precision.
+         */
+        "no-loss-of-precision": "off",
+        "@typescript-eslint/no-loss-of-precision": baseRules["no-loss-of-precision"],
+
+        /**
+         * Disallow magic numbers.
+         * Https://typescript-eslint.io/rules/no-magic-numbers.
+         */
+        "no-magic-numbers": "off",
+        "@typescript-eslint/no-magic-numbers": baseRules["no-magic-numbers"],
+
+        /**
+         * Disallow the void operator except when used to discard a value 🔒 🔧 💡 💭
+         * https://typescript-eslint.io/rules/no-meaningless-void-operator.
+         */
+        "@typescript-eslint/no-meaningless-void-operator": "warn",
+
+        /**
+         * Enforce valid definition of new and constructor ✅
+         * https://typescript-eslint.io/rules/no-misused-new.
+         */
+        "@typescript-eslint/no-misused-new": "error",
+
+        /**
+         * Disallow Promises in places not designed to handle them ✅ 💭
+         * https://typescript-eslint.io/rules/no-misused-promises.
+         */
+        "@typescript-eslint/no-misused-promises": "error",
+
+        /**
+         * Disallow custom TypeScript modules and namespaces ✅
+         * https://typescript-eslint.io/rules/no-namespace.
+         */
+        "@typescript-eslint/no-namespace": "error",
+
+        /**
+         * Disallow non-null assertions in the left operand of a nullish coalescing operator 🔒 💡
+         * https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing.
+         */
+        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "warn",
+
+        /**
+         * Disallow non-null assertions after an optional chain expression ✅ 💡
+         * https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain.
+         */
+        "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+
+        /**
+         * Disallow non-null assertions using the ! Postfix operator ✅ 💡
+         * https://typescript-eslint.io/rules/no-non-null-assertion.
+         */
+        "@typescript-eslint/no-non-null-assertion": "warn",
+
+        /**
+         * Disallow variable re-declaration.
+         * Https://typescript-eslint.io/rules/no-redeclare.
+         */
+        "no-redeclare": "off",
+        "@typescript-eslint/no-redeclare": baseRules["no-redeclare"],
+
+        /**
+         * Disallow members of unions and intersections that do nothing or override type information 💭
+         * https://typescript-eslint.io/rules/no-redundant-type-constituents.
+         */
+        "@typescript-eslint/no-redundant-type-constituents": "warn",
+
+        /**
+         * Disallow invocation of require()
+         * https://typescript-eslint.io/rules/no-require-imports.
+         */
+        "@typescript-eslint/no-require-imports": "warn",
+
+        /**
+         * Disallow unnecessary return await
+         * https://typescript-eslint.io/rules/return-await.
+         */
+        "no-return-await": "off",
+        "@typescript-eslint/return-await": "warn",
+
+        /**
+         * Disallow specified modules when loaded by import.
+         * Https://typescript-eslint.io/rules/no-restricted-imports.
+         */
+        "no-restricted-imports": "off",
+        "@typescript-eslint/no-restricted-imports": baseRules["no-restricted-imports"],
+
+        /**
+         * Disallow variable declarations from shadowing variables declared in the outer scope
+         * https://typescript-eslint.io/rules/no-shadow.
+         */
+        "no-shadow": "off",
+        "@typescript-eslint/no-shadow": baseRules["no-shadow"],
+
+        /**
+         * Disallow aliasing this ✅
+         * https://typescript-eslint.io/rules/no-this-alias.
+         */
+        "@typescript-eslint/no-this-alias": "error",
+
+        /**
+         * Disallow throwing literals as exceptions
+         * https://typescript-eslint.io/rules/no-throw-literal.
+         */
+        "no-throw-literal": "off",
+        "@typescript-eslint/no-throw-literal": "error",
+
+        /**
+         * Disallow type aliases
+         * https://typescript-eslint.io/rules/no-type-alias.
+         */
+        "@typescript-eslint/no-type-alias": "off",
+
+        /**
+         * Disallow unnecessary equality comparisons against boolean literals 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare.
+         */
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": "warn",
+
+        /**
+         * Disallow conditionals where the type is always truthy or always falsy 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/no-unnecessary-condition.
+         */
+        "@typescript-eslint/no-unnecessary-condition": "warn",
+
+        /**
+         * Disallow unnecessary namespace qualifiers 🔧 💭
+         * https://typescript-eslint.io/rules/no-unnecessary-qualifier.
+         */
+        "@typescript-eslint/no-unnecessary-qualifier": "warn",
+
+        /**
+         * Disallow type arguments that are equal to the default 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/no-unnecessary-type-arguments.
+         */
+        "@typescript-eslint/no-unnecessary-type-arguments": "warn",
+
+        /**
+         * Disallow type assertions that do not change the type of an expression ✅ 🔧 💭
+         * https://typescript-eslint.io/rules/no-unnecessary-type-assertion.
+         */
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
+
+        /**
+         * Disallow unnecessary constraints on generic types ✅ 💡
+         * https://typescript-eslint.io/rules/no-unnecessary-type-constraint.
+         */
+        "@typescript-eslint/no-unnecessary-type-constraint": "error",
+
+        /**
+         * Disallow calling a function with a value with type any ✅ 💭
+         * https://typescript-eslint.io/rules/no-unsafe-argument.
+         */
+        "@typescript-eslint/no-unsafe-argument": "error",
+
+        /**
+         * Disallow assigning a value with type any to variables and properties ✅ 💭
+         * Off: catched by tsc
+         * https://typescript-eslint.io/rules/no-unsafe-assignment.
+         */
+        "@typescript-eslint/no-unsafe-assignment": "off",
+
+        /**
+         * Disallow calling a value with type any ✅ 💭
+         * Off: gives too much false positive
+         * https://typescript-eslint.io/rules/no-unsafe-call.
+         */
+        "@typescript-eslint/no-unsafe-call": "off",
+
+        /**
+         * Disallow member access on a value with type any ✅ 💭
+         * https://typescript-eslint.io/rules/no-unsafe-member-access.
+         */
+        "@typescript-eslint/no-unsafe-member-access": "off",
+
+        /**
+         * Disallow returning a value with type any from a function ✅ 💭
+         * https://typescript-eslint.io/rules/no-unsafe-return.
+         */
+        "@typescript-eslint/no-unsafe-return": "error",
+
+        /**
+         * Disallow unused expressions
+         * https://typescript-eslint.io/rules/no-unused-expressions.
+         */
+        "no-unused-expressions": "off",
+        "@typescript-eslint/no-unused-expressions": baseRules["no-unused-expressions"],
+
+        /**
+         * Disallow unused variables
+         * https://typescript-eslint.io/rules/no-unused-vars.
+         */
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": baseRules["no-unused-vars"],
+
+        /**
+         * Disallow the use of variables before they are defined
+         * https://typescript-eslint.io/rules/no-use-before-define.
+         */
+        "no-use-before-define": "off",
+        "@typescript-eslint/no-use-before-define": baseRules["no-use-before-define"],
+
+        /**
+         * Disallow unnecessary constructors
+         * https://typescript-eslint.io/rules/no-useless-constructor.
+         */
+        "no-useless-constructor": "off",
+        "@typescript-eslint/no-useless-constructor": baseRules["no-useless-constructor"],
+
+        /**
+         * Disallow empty exports that don"t change anything in a module file 🔧
+         * https://typescript-eslint.io/rules/no-useless-empty-export.
+         */
+        "@typescript-eslint/no-useless-empty-export": "warn",
+
+        /**
+         * Disallow require statements except in import statements ✅
+         * https://typescript-eslint.io/rules/no-var-requires.
+         */
+        "@typescript-eslint/no-var-requires": "error",
+
+        /**
+         * Enforce non-null assertions over explicit type casts 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/non-nullable-type-assertion-style.
+         */
+        "@typescript-eslint/non-nullable-type-assertion-style": "warn",
+
+        /**
+         * Require or disallow parameter properties in class constructors
+         * https://typescript-eslint.io/rules/parameter-properties.
+         */
+        "@typescript-eslint/parameter-properties": [
+            "warn",
+            {
+                allow: [],
+                prefer: "parameter-property",
+            },
+        ],
+
+        /**
+         * Enforce the use of as const over literal type ✅ 🔧 💡
+         * https://typescript-eslint.io/rules/.
+         */
+        "@typescript-eslint/prefer-as-const": "error",
+
+        /**
+         * Require each enum member value to be explicitly initialized 💡
+         * https://typescript-eslint.io/rules/prefer-enum-initializers.
+         */
+        "@typescript-eslint/prefer-enum-initializers": "warn",
+
+        /**
+         * Enforce the use of for-of loop over the standard for loop where possible 🔒
+         * https://typescript-eslint.io/rules/.
+         */
+        "@typescript-eslint/prefer-for-of": "error",
+
+        /**
+         * Enforce using function types instead of interfaces with call signatures 🔒 🔧
+         * https://typescript-eslint.io/rules/prefer-function-type.
+         */
+        "@typescript-eslint/prefer-function-type": "error",
+
+        /**
+         * Enforce includes method over indexOf method 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-includes.
+         */
+        "@typescript-eslint/prefer-includes": "warn",
+
+        /**
+         * Require all enum members to be literal values 🔒
+         * https://typescript-eslint.io/rules/prefer-literal-enum-member.
+         */
+        "@typescript-eslint/prefer-literal-enum-member": "warn",
+
+        /**
+         * Require using namespace keyword over module keyword to declare custom TypeScript modules ✅ 🔧
+         * https://typescript-eslint.io/rules/prefer-namespace-keyword.
+         */
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+
+        /**
+         * Enforce using the nullish coalescing operator instead of logical chaining 🔒 💡 💭
+         * https://typescript-eslint.io/rules/prefer-nullish-coalescing.
+         */
+        "@typescript-eslint/prefer-nullish-coalescing": "warn",
+
+        /**
+         * Enforce using concise optional chain expressions instead of chained logical ands 🔒 💡
+         * https://typescript-eslint.io/rules/.
+         */
+        "@typescript-eslint/prefer-optional-chain": "warn",
+
+        /**
+         * Require private members to be marked as readonly if they"re never modified outside of the constructor 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-readonly.
+         */
+        "@typescript-eslint/prefer-readonly": "warn",
+
+        /**
+         * Require function parameters to be typed as readonly to prevent accidental mutation of inputs 💭
+         * https://typescript-eslint.io/rules/prefer-readonly-parameter-types.
+         */
+        "@typescript-eslint/prefer-readonly-parameter-types": "warn",
+
+        /**
+         * Enforce using type parameter when calling Array#reduce instead of casting 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-reduce-type-parameter.
+         */
+        "@typescript-eslint/prefer-reduce-type-parameter": "warn",
+
+        /**
+         * Enforce RegExp#exec over String#match if no global flag is provided 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-regexp-exec.
+         */
+        "@typescript-eslint/prefer-regexp-exec": "warn",
+
+        /**
+         * Enforce that this is used when only this type is returned 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-return-this-type.
+         */
+        "@typescript-eslint/prefer-return-this-type": "warn",
+
+        /**
+         * Enforce using String#startsWith and String#ends
+         * With over other equivalent methods of checking substrings 🔒 🔧 💭
+         * https://typescript-eslint.io/rules/prefer-string-starts-ends-with.
+         */
+        "@typescript-eslint/prefer-string-starts-ends-with": "warn",
+
+        /**
+         * Enforce using @ts-expect-error over @ts-ignore 🔒 🔧
+         * https://typescript-eslint.io/rules/prefer-ts-expect-error.
+         */
+        "@typescript-eslint/prefer-ts-expect-error": "warn",
+
+        /**
+         * Require any function or method that returns a Promise to be marked async 🔧 💭
+         * https://typescript-eslint.io/rules/promise-function-async.
+         */
+        "@typescript-eslint/promise-function-async": "error",
+
+        /**
+         * Enforce the consistent use of double quotes
+         * https://typescript-eslint.io/rules/quotes.
+         */
+        quotes: "off",
+        "@typescript-eslint/quotes": baseRules.quotes,
+
+        /**
+         * Require Array#sort calls to always provide a compareFunction 💭
+         * https://typescript-eslint.io/rules/require-array-sort-compare.
+         */
+        "@typescript-eslint/require-array-sort-compare": ["warn", { ignoreStringArrays: true }],
+
+        /**
+         * Disallow async functions which have no await expression
+         * https://typescript-eslint.io/rules/require-await.
+         */
+        "require-await": "off",
+        "@typescript-eslint/require-await": baseRules["require-await"],
+
+        /**
+         * Require both operands of addition to have type number or string ✅ 💭
+         * Off: not really needed
+         * https://typescript-eslint.io/rules/restrict-plus-operands.
+         */
+        "@typescript-eslint/restrict-plus-operands": "off",
+
+        /**
+         * Enforce template literal expressions to be of string type ✅  💭
+         * https://typescript-eslint.io/rules/.
+         */
+        "@typescript-eslint/restrict-template-expressions": "error",
+
+        /**
+         * Require or disallow semicolons instead of ASI.
+         * Https://typescript-eslint.io/rules/semi.
+         */
+        semi: "off",
+        "@typescript-eslint/semi": baseRules.semi,
+
+        /**
+         * Enforce members of a type union/intersection to be sorted alphabetically 🔧 💡
+         * https://typescript-eslint.io/rules/sort-type-union-intersection-members.
+         */
+        "@typescript-eslint/sort-type-union-intersection-members": "off",
+
+        /**
+         * Disallow certain types in boolean expressions 🔧 💡 💭
+         * https://typescript-eslint.io/rules/strict-boolean-expressions.
+         */
+        "@typescript-eslint/strict-boolean-expressions": "off",
+
+        /**
+         * Require switch-case statements to be exhaustive with union type 💡 💭
+         * https://typescript-eslint.io/rules/switch-exhaustiveness-check.
+         */
+        "@typescript-eslint/switch-exhaustiveness-check": "warn",
+
+        /**
+         * Disallow certain triple slash directives in favor of ES6-style import declarations ✅
+         * https://typescript-eslint.io/rules/triple-slash-reference.
+         */
+        "@typescript-eslint/triple-slash-reference": [
+            "error",
+            {
+                path: "always",
+                types: "prefer-import",
+                lib: "always",
+            },
+        ],
+
+        /**
+         * Require type annotations in certain places
+         * https://typescript-eslint.io/rules/typedef.
+         */
+        "@typescript-eslint/typedef": "warn",
+
+        /**
+         * Enforce unbound methods are called with their expected scope ✅ 💭
+         * While this rule should be enabled, it gives to many problems with external libraries
+         * https://typescript-eslint.io/rules/unbound-method.
+         */
+        "@typescript-eslint/unbound-method": "off",
+
+        /**
+         * Disallow two overloads that could be unified into one with a union or an optional/rest parameter
+         * https://typescript-eslint.io/rules/unified-signatures.
+         */
+        "@typescript-eslint/unified-signatures": "error",
+
+        // =================   Formatting rules =======================
+
+        /**
+         * Enforce consistent brace style for blocks.
+         * Https://typescript-eslint.io/rules/brace-style.
+         */
+        "brace-style": "off",
+        "@typescript-eslint/brace-style": baseRules["brace-style"],
+
+        /**
+         * Enforce consistent spacing before and after commas.
+         * Https://typescript-eslint.io/rules/comma-spacing.
+         */
+        "comma-spacing": "off",
+        "@typescript-eslint/comma-spacing": baseRules["comma-spacing"],
+
+        /**
+         * Require or disallow spacing between function identifiers and their invocations.
+         * Https://typescript-eslint.io/rules/func-call-spacing.
+         */
+        "func-call-spacing": "off",
+        "@typescript-eslint/func-call-spacing": baseRules["func-call-spacing"],
+
+        /**
+         * Enforce consistent indentation.
+         * Https://typescript-eslint.io/rules/indent.
+         */
+        indent: "off",
+        "@typescript-eslint/indent": baseRules.indent,
+
+        /**
+         * Enforce consistent spacing before and after keywords.
+         * Https://typescript-eslint.io/rules/keyword-spacing.
+         */
+        "keyword-spacing": "off",
+        "@typescript-eslint/keyword-spacing": baseRules["keyword-spacing"],
+
+        /**
+         * Require or disallow an empty line between class members.
+         * Https://typescript-eslint.io/rules/lines-between-class-members.
+         */
+        "lines-between-class-members": "off",
+        "@typescript-eslint/lines-between-class-members": baseRules["lines-between-class-members"],
+
+        /**
+         * Enforce consistent spacing inside braces.
+         * Https://typescript-eslint.io/rules/object-curly-spacing.
+         */
+        "object-curly-spacing": "off",
+        "@typescript-eslint/object-curly-spacing": baseRules["object-curly-spacing"],
+
+        /**
+         * Require or disallow padding lines between statements.
+         * Https://typescript-eslint.io/rules/padding-line-between-statements.
+         */
+        "padding-line-between-statements": "off",
+        "@typescript-eslint/padding-line-between-statements": baseRules["padding-line-between-statements"],
+
+        /**
+         * Enforce consistent spacing before blocks.
+         * Https://typescript-eslint.io/rules/space-before-blocks.
+         */
+        "space-before-blocks": "off",
+        "@typescript-eslint/space-before-blocks": baseRules["space-before-blocks"],
+
+        /**
+         * Enforce consistent spacing before function parenthesis.
+         * Https://typescript-eslint.io/rules/space-before-function-paren.
+         */
+        "space-before-function-paren": "off",
+        "@typescript-eslint/space-before-function-paren": baseRules["space-before-function-paren"],
+
+        /**
+         * Require spacing around infix operators.
+         * Https://typescript-eslint.io/rules/space-infix-ops.
+         */
+        "space-infix-ops": "off",
+        "@typescript-eslint/space-infix-ops": baseRules["space-infix-ops"],
+
+        /**
+         * Require consistent spacing around type annotations
+         * https://typescript-eslint.io/rules/type-annotation-spacing.
+         */
+        "@typescript-eslint/type-annotation-spacing": "warn",
+
+        // Append "ts" and "tsx" to Airbnb "import/extensions" rule
+        "import/extensions": [
+            baseImportsRules["import/extensions"][0],
+            baseImportsRules["import/extensions"][1],
+            {
+                ...baseImportsRules["import/extensions"][2],
+                ts: "never",
+                tsx: "never",
+            },
+        ],
+
+        // Append "ts" and "tsx" extensions to Airbnb "import/no-extraneous-dependencies" rule
+        "import/no-extraneous-dependencies": [
+            baseImportsRules["import/no-extraneous-dependencies"][0],
+            {
+                ...baseImportsRules["import/no-extraneous-dependencies"][1],
+                devDependencies: baseImportsRules["import/no-extraneous-dependencies"][1].devDependencies.reduce(
+                    (result, devDep) => {
+                        const toAppend = [devDep];
+                        const devDepWithTs = devDep.replace(/\bjs(x?)\b/g, "ts$1");
+                        if (devDepWithTs !== devDep) {
+                            toAppend.push(devDepWithTs);
+                        }
+                        return [...result, ...toAppend];
+                    },
+                ),
+            },
+        ],
+    },
+};