@josundt/eslint-config 4.9.7 → 5.2.0

package/rules/typescript-eslint/extensionrules.js

@@ -0,0 +1,124 @@
+const eslintRuleSet = require("../eslint.js");
+const { deepMergeObjects } = require("../../utils/merge.js");
+
+const eslintRules = eslintRuleSet.rules;
+
+// Map of all the typescript-eslint extensions.
+// If extension rule has additional properties compared to standard eslint rule:
+// If the map value is null:
+//     The options from the standard rule will be used as is.
+// If the map value is an object:
+//     The object will be merged merged with standard rule (rule object 1).
+// If the map value is an array:
+//     The items of the array will be added as a new rule options object.
+// If the map value is a function:
+//     The standard eslint options object will be passed as parameters, the return statement will be added as options.
+
+const extensions = new Map([
+    ["default-param-last", true],
+    [
+        "dot-notation",
+        {
+            allowPrivateClassPropertyAccess: false,
+            allowProtectedClassPropertyAccess: false,
+            allowIndexSignaturePropertyAccess: false
+        }
+    ],
+    ["init-declarations", true],
+    [
+        "lines-between-class-members",
+        {
+            exceptAfterOverload: true
+        }
+    ],
+    ["no-array-constructor", true],
+    ["no-dupe-class-members", true],
+    ["no-duplicate-imports", true],
+    [
+        "no-empty-function",
+        {
+            allow: [
+                "private-constructors",
+                "protected-constructors" /* "decoratedFunctions", "overrideMethods" */
+            ]
+        }
+    ],
+    ["no-extra-semi", true],
+    ["no-implied-eval", true],
+    ["no-invalid-this", false],
+    ["no-loop-func", true],
+    ["no-loss-of-precision", true],
+    ["no-magic-numbers", true],
+    ["no-redeclare", true],
+    ["no-restricted-imports", true],
+    [
+        "no-shadow",
+        v => {
+            const o = {
+                ...v,
+                ignoreTypeValueShadow: true,
+                ignoreFunctionTypeParameterNameValueShadow: true
+            };
+            delete o["ignoreOnInitialization"]; // Temporary bug in @typescript/eslint "no-shadow" extension rule - "ignoreOnInitialization" property considered invalid
+            return o;
+        }
+    ],
+    ["no-throw-literal", true],
+    ["no-unused-expressions", true],
+    ["no-unused-vars", false],
+    ["no-use-before-define", false],
+    ["no-useless-constructor", false],
+    ["require-await", true],
+    ["return-await", true]
+]);
+
+// console.log(extensionRules);
+// console.log(`Converted ${Object.keys(extensionRules).filter(k => !k.startsWith("@typescript")).length} of ${extensions.size} available extension rules`);
+// console.log("Not converted:", Array.from(extensions.keys()).filter(k => !Object.keys(extensionRules).filter(k => !k.startsWith("@typescript")).includes(k)));
+
+// Building eslint-typescript rules for existsing eslint rules and switching off original eslint rule
+module.exports.typescriptEslintExtensionrules = Object.entries(
+    eslintRules
+).reduce((extRules, [key, value]) => {
+    // Try to get from known extensions map
+    const extension = extensions.get(key);
+
+    // If found in known typescript eslint extension rules map
+    if (extension !== undefined) {
+        // Switch off standard eslint rule
+        extRules[key] = "off";
+
+        // Special handling of certain extension rules that need to be switched off:
+        if (extension === false) {
+            extRules[`@typescript-eslint/${key}`] = "off";
+        } else {
+            // If extension rule has extended options, merge with standard eslint rule options:
+            if (extension !== true) {
+                // Ensure value is array if only severity string:
+                value = Array.isArray(value) ? [...value] : [value];
+                if (Array.isArray(extension)) {
+                    value.push(...extension);
+                } else if (typeof extension === "object") {
+                    // If array only contains severity string, push object
+                    if (value.length === 1) {
+                        value.push(extension);
+                        // Else merge object
+                    } else {
+                        value[value.length - 1] = deepMergeObjects(
+                            value[value.length - 1],
+                            extension
+                        );
+                    }
+                } else if (typeof extension === "function") {
+                    const [, ...options] = value;
+                    value[value.length - 1] = { ...extension(...options) };
+                }
+            }
+            // Add extension rule value with the @typescript-eslint key prefix
+            extRules[`@typescript-eslint/${key}`] = value;
+        }
+    }
+    // else: if no extension rule exists, the standard eslint rule will be used through the "extends" configuration below
+
+    return extRules;
+}, {});

package/rules/typescript-eslint/rules.js

@@ -0,0 +1,299 @@
+/* Main @typescript-eslint rules */
+const rules = {
+    "adjacent-overload-signatures": "error",
+    "array-type": [
+        "error",
+        {
+            default: "array-simple",
+            readonly: "array-simple"
+        }
+    ],
+    "await-thenable": "error",
+    "ban-ts-comment": [
+        "error",
+        {
+            "ts-expect-error": "allow-with-description",
+            "ts-ignore": true,
+            "ts-nocheck": true,
+            "ts-check": false,
+            "minimumDescriptionLength": 10
+            //"descriptionFormat": "someformathere"
+        }
+    ],
+    "ban-tslint-comment": "error", // No longer use tslint - remove rules
+    "ban-types": "off", // Can be used to ban certain types
+    "class-literal-property-style": "off",
+    "consistent-generic-constructors": ["off", "constructor"],
+    "consistent-indexed-object-style": ["error", "record"],
+    "consistent-type-assertions": [
+        "error",
+        {
+            assertionStyle: "as",
+            objectLiteralTypeAssertions: "allow"
+        }
+    ],
+    "consistent-type-definitions": ["error", "interface"],
+    "consistent-type-exports": [
+        "error",
+        {
+            fixMixedExportsWithInlineTypeSpecifier: true
+        }
+    ],
+    "consistent-type-imports": [
+        "error",
+        {
+            prefer: "type-imports",
+            fixStyle: "inline-type-imports",
+            disallowTypeAnnotations: false
+        }
+    ],
+    "explicit-function-return-type": [
+        "error",
+        {
+            allowConciseArrowFunctionExpressionsStartingWithVoid: true,
+            allowExpressions: true,
+            allowFunctionsWithoutTypeParameters: false,
+            allowHigherOrderFunctions: true,
+            allowIIFEs: false,
+            allowTypedFunctionExpressions: true,
+            allowedNames: []
+        }
+    ],
+    "explicit-member-accessibility": [
+        "error",
+        {
+            accessibility: "no-public"
+        }
+    ],
+    "explicit-module-boundary-types": [
+        // same as "recommended" except error instead of warning
+        "error",
+        {
+            allowArgumentsExplicitlyTypedAsAny: false,
+            allowDirectConstAssertionInArrowFunctions: true,
+            allowHigherOrderFunctions: true,
+            allowTypedFunctionExpressions: true,
+            allowedNames: []
+        }
+    ],
+    "member-delimiter-style": [
+        "error",
+        {
+            multiline: {
+                delimiter: "semi",
+                requireLast: true
+            },
+            singleline: {
+                delimiter: "semi",
+                requireLast: false
+            }
+        }
+    ],
+    "member-ordering": "off",
+    "method-signature-style": "off", // useful rule since lambda method notation enforces stricter type checking, but has somme inconveniences for ovelaoads, "implement interface" refactoring, and general code complexity
+    "naming-convention": [
+        "error",
+        {
+            selector: "default",
+            format: ["camelCase"],
+            leadingUnderscore: "forbid",
+            trailingUnderscore: "forbid"
+        },
+        {
+            selector: "typeLike",
+            format: ["PascalCase"]
+        },
+        {
+            selector: "method",
+            modifiers: [
+                // "#private", // Did not work even if it was added in 5.49.0
+                "private"
+            ],
+            format: ["camelCase"],
+            leadingUnderscore: "allow",
+            trailingUnderscore: "forbid"
+        },
+        {
+            selector: "property",
+            modifiers: [
+                // "#private", // Did not work even if it was added in 5.49.0
+                "private"
+            ],
+            format: ["camelCase"],
+            leadingUnderscore: "allow",
+            trailingUnderscore: "forbid"
+        },
+        {
+            selector: "enumMember",
+            format: ["camelCase", "PascalCase"]
+        }
+    ],
+    "no-base-to-string": "error",
+    "no-confusing-non-null-assertion": "error",
+    "no-confusing-void-expression": [
+        "error",
+        {
+            ignoreArrowShorthand: true
+        }
+    ],
+    "no-duplicate-enum-values": "error",
+    "no-duplicate-type-constituents": "error",
+    "no-dynamic-delete": "error",
+    "no-empty-interface": "off",
+    "no-explicit-any": [
+        "off",
+        {
+            ignoreRestArgs: "false"
+        }
+    ],
+    "no-extra-non-null-assertion": "error",
+    "no-extraneous-class": "error",
+    "no-floating-promises": "error", // Must be switched on to prevent promises not awaited
+    "no-for-in-array": "error",
+    "no-import-type-side-effects": "error",
+    "no-inferrable-types": "off",
+    "no-invalid-void-type": [
+        "error",
+        {
+            allowInGenericTypeArguments: true,
+            allowAsThisParameter: true
+        }
+    ],
+    "no-meaningless-void-operator": "error",
+    "no-misused-new": "error",
+    "no-misused-promises": [
+        "error",
+        {
+            checksConditionals: true,
+            checksSpreads: true,
+            checksVoidReturn: true // {
+            //     arguments: true, //Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns void
+            //     attributes: true, //Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns void
+            //     properties: true, //Disables checking an asynchronous function passed as an object property expected to be a function that returns void
+            //     returns: true, //Disables checking an asynchronous function returned in a function whose return type is a function that returns void
+            //     variables: true //Disables checking an asynchronous function used as a variable whose return type is a function that returns void
+            // }
+        }
+    ],
+    "no-mixed-enums": "error",
+    "no-namespace": "off",
+    "no-non-null-asserted-nullish-coalescing": "error",
+    "no-non-null-asserted-optional-chain": "error",
+    "no-non-null-assertion": "off",
+    "no-redundant-type-constituents": "error",
+    "no-require-imports": "error",
+    "no-unsafe-enum-comparison": "error",
+    "no-this-alias": "error",
+    "no-throw-literal": [
+        "error",
+        {
+            allowThrowingAny: false, // Default is to allow throwing values of type any
+            allowThrowingUnknown: true // Default is to allow throwing values of type unknown
+        }
+    ],
+    "no-type-alias": "off",
+    "no-unnecessary-boolean-literal-compare": "error",
+    "no-unnecessary-condition": "off", // allow runtime null checks etc even if reported not necessary by type system
+    "no-unnecessary-qualifier": "error",
+    "no-unnecessary-type-arguments": "off",
+    "no-unnecessary-type-assertion": "off",
+    "no-unnecessary-type-constraint": "error",
+    "no-unsafe-argument": "error",
+    "no-unsafe-assignment": "error",
+    "no-unsafe-call": "error",
+    "no-unsafe-member-access": "error",
+    "no-unsafe-return": "error",
+    "no-unused-vars-experimental": "off", // to strict with method params...
+    "no-useless-empty-export": "error",
+    "no-var-requires": "error",
+    "non-nullable-type-assertion-style": "error",
+    "parameter-properties": [
+        "error",
+        {
+            prefer: "class-property", // or "parameter-property"
+            allow: ["private readonly", "private", "protected readonly"]
+        }
+    ],
+    "prefer-as-const": "off",
+    "prefer-enum-initializers": "error",
+    "prefer-for-of": "error",
+    "prefer-function-type": "error",
+    "prefer-includes": "error",
+    "prefer-literal-enum-member": "error",
+    "prefer-namespace-keyword": "error",
+    "prefer-nullish-coalescing": [
+        "error",
+        {
+            ignoreConditionalTests: true,
+            ignoreTernaryTests: true,
+            ignoreMixedLogicalExpressions: true
+        }
+    ],
+    "prefer-optional-chain": "error",
+    "prefer-readonly": "error",
+    "prefer-readonly-parameter-types": "off", // Could be useful but requires too much work and verbose notation
+    "prefer-reduce-type-parameter": "error",
+    "prefer-regexp-exec": "error",
+    "prefer-return-this-type": "error",
+    "prefer-string-starts-ends-with": "error",
+    "prefer-ts-expect-error": "error",
+    "promise-function-async": "off",
+    "require-array-sort-compare": "error",
+    "restrict-plus-operands": [
+        "error",
+        {
+            checkCompoundAssignments: true,
+            allowAny: false
+        }
+    ],
+    "restrict-template-expressions": [
+        "error",
+        {
+            allowAny: false,
+            allowBoolean: false,
+            allowNever: false,
+            allowNullish: false,
+            allowNumber: true,
+            allowRegExp: false
+        }
+    ],
+    "sort-type-constituents": "off",
+    "strict-boolean-expressions": [
+        "off",
+        {
+            allowString: true,
+            allowNumber: true,
+            allowNullableObject: true,
+            allowNullableString: true,
+            allowNullableNumber: true,
+            allowNullableBoolean: true,
+            allowAny: false
+        }
+    ],
+    "switch-exhaustiveness-check": "error",
+    "triple-slash-reference": "error",
+    "type-annotation-spacing": "error", // This is a formatting rule
+    "typedef": [
+        "error",
+        {
+            arrayDestructuring: false,
+            arrowParameter: false,
+            memberVariableDeclaration: true,
+            objectDestructuring: false,
+            parameter: true,
+            propertyDeclaration: true,
+            variableDeclaration: false
+        }
+    ],
+    "unbound-method": "error",
+    "unified-signatures": "off"
+};
+
+// Rules - append "@typescript-eslint/" to rule names
+module.exports.typescriptEslintRules = Object.entries(rules).reduce(
+    (aggr, [key, value]) => ({
+        ...aggr,
+        [`@typescript-eslint/${key}`]: value
+    }),
+    {}
+);