@josundt/eslint-config 4.4.0 → 4.7.3

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@josundt/eslint-config",
-  "version": "4.4.0",
+  "version": "4.7.3",
   "description": "ESLint ruleset with required plugins for josundt TypeScript projects",
-  "main": ".eslintrc.js",
+  "main": "index.js",
   "scripts": {
     "lint": "echo \"No linting for this project\"",
     "build": "echo \"No build for this project\"",
@@ -23,19 +23,21 @@
   "license": "ISC",
   "files": [
     "*.js",
-    "rules/**/*.js"
+    "rules/**/*.js",
+    "utils/**/*.js"
   ],
   "peerDependencies": {
-    "typescript": ">=4.4.2"
+    "typescript": ">=4.7.2"
   },
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "4.30.0",
-    "@typescript-eslint/parser": "4.30.0",
-    "eslint": "7.32.0",
-    "eslint-import-resolver-typescript": "2.4.0",
-    "eslint-plugin-deprecation": "1.2.1",
-    "eslint-plugin-import": "2.24.2",
-    "eslint-plugin-jasmine": "4.1.2",
-    "eslint-plugin-jsdoc": "36.0.8",
-    "eslint-plugin-unicorn": "35.0.0"
-  }}
+    "@typescript-eslint/eslint-plugin": "5.27.0",
+    "@typescript-eslint/parser": "5.27.0",
+    "eslint": "8.16.0",
+    "eslint-import-resolver-typescript": "2.7.1",
+    "eslint-plugin-deprecation": "1.3.2",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-jasmine": "4.1.3",
+    "eslint-plugin-jsdoc": "39.3.2",
+    "eslint-plugin-unicorn": "42.0.0"
+  }
+}

package/rules/eslint.js

@@ -61,7 +61,7 @@ module.exports = {
         ],
         "guard-for-in": "error",
         "handle-callback-err": "error",
-        "id-blacklist": [
+        "id-denylist": [
             "error",
             "any",
             "Number",
@@ -86,7 +86,14 @@ module.exports = {
                 "FunctionExpression": {
                     "parameters": "first"
                 },
-                "SwitchCase": 1
+                "SwitchCase": 1,
+
+                // Fix to decorator indentation problem
+                "ignoredNodes": [
+                    "FunctionExpression > .params[decorators.length > 0]",
+                    "FunctionExpression > .params > :matches(Decorator, :not(:first-child))",
+                    "ClassBody.body > PropertyDefinition[decorators.length > 0] > .key"
+                ]
             }
         ],
         "init-declarations": "off",
@@ -134,7 +141,9 @@ module.exports = {
         "no-duplicate-imports": "error",
         "no-empty": "error",
         "no-empty-character-class": "error",
-        "no-empty-function": "error",
+        "no-empty-function": ["error", {
+            //allow: [/*"functions", "arrowFunctions", "generatorFunctions", "methods", "generatorMethods", "getters", "setters", "constructors", "asyncFunctions", "asyncMethods"*/]
+        }],
         "no-eval": "error",
         "no-ex-assign": "error",
         "no-extra-bind": "error",
@@ -198,7 +207,10 @@ module.exports = {
         "no-shadow": [
             "error",
             {
-                "hoist": "all"
+                "hoist": "all",
+                "builtinGlobals": false,
+                "ignoreOnInitialization": false,
+                "allow": [] // array of identifier names for which shadowing is allowed
             }
         ],
         "no-sparse-arrays": "error",
@@ -219,7 +231,8 @@ module.exports = {
             "error",
             {
                 "vars": "all",
-                "args": "none"
+                "args": "none",
+                "destructuredArrayIgnorePattern": "^_"
             }
         ],
         "no-use-before-define": "error",
@@ -236,12 +249,17 @@ module.exports = {
             "never"
         ],
         "padding-line-between-statements": [
-            "off",
-            {
-                "blankLine": "always",
-                "prev": "*",
-                "next": "return"
-            }
+            "error",
+            { "blankLine": "always", "prev": ["directive", "import"],                 "next": "*" },
+            { "blankLine": "any",    "prev": ["directive", "import"],                 "next": ["directive", "import"] },
+
+            { "blankLine": "always", "prev": "*",                                     "next": ["export", "class", "function", "iife"] },
+            { "blankLine": "always", "prev": ["export", "class", "function", "iife"], "next": "*" },
+
+            // { "blankLine": "always", "prev": "*",                                     "next": "return" }, // Newline before return
+
+            // { "blankLine": "always", "prev": "*",                                     "next": "multiline-block-like" }, // Newline BEFORE multiline block
+            // { "blankLine": "always", "prev": "multiline-block-like",                  "next": "*" }                     // Newline AFTER  multiline block
         ],
         "prefer-arrow-callback": "error",
         "prefer-const": "error",
@@ -262,8 +280,12 @@ module.exports = {
             "error",
             "always"
         ],
+        "space-before-blocks": [
+            "error",
+            "always"
+        ],
         "space-before-function-paren": [
-            "warn",
+            "error",
             {
                 "anonymous": "always",
                 "asyncArrow": "always",

package/rules/import-typescript.js

@@ -8,12 +8,13 @@ module.exports = {
     "rules": {
         "import/extensions": [ // Ensure all local .ts file imports use .js extension
             "error",
-            "always"
+            "ignorePackages"
         ],
         "import/no-commonjs": "error", // Disallow require() syntax - only esm syntax allowed
         "import/no-nodejs-modules": "error", // Disallowed: import * as path from "path"; Allowed: import * as path from "node:path";
         "import/no-default-export": "off",
         "import/no-deprecated": "error",
+        "import/no-duplicates": "error",
         "import/no-extraneous-dependencies": "off",
         "import/no-internal-modules": "off",
         "import/no-unassigned-import": "error",

package/rules/typescript-eslint.js

@@ -1,9 +1,16 @@
-const eslintRuleSet = require("./eslint");
+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,
-// the value of the map item has an object that will be merged with standard rule; otherwise null.
+// If extension rule has additional properties compared to standard eslint rule:
+// 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([
     ["brace-style", null],
     ["comma-dangle", null],
@@ -23,38 +30,51 @@ const extensions = new Map([
     }],
     ["no-array-constructor", null],
     ["no-dupe-class-members", null],
-    ["no-duplicate-imports", null],
-    ["no-empty-function", null],
+    ["no-empty-function", {
+        allow: ["private-constructors", "protected-constructors" /* "decoratedFunctions", "overrideMethods" */ ]
+    }],
     ["no-extra-parens", null],
     ["no-extra-semi", null],
     ["no-invalid-this", null],
     ["no-loop-func", null],
     ["no-loss-of-precision", null],
     ["no-magic-numbers", null],
-    ["no-shadow", {
-        "ignoreTypeValueShadow": true,
-        "ignoreFunctionTypeParameterNameValueShadow": 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-unused-expressions", null],
     ["no-unused-vars", null],
     ["no-use-before-define", null],
     ["no-useless-constructor", null],
     ["object-curly-spacing", null],
+    ["padding-line-between-statements", [
+        { "blankLine": "always", "prev": "*", "next": ["interface", "type"] },
+        { "blankLine": "always", "prev": ["interface", "type"], "next": "*" }
+    ]],
     ["quotes", null],
     ["require-await", null],
     ["return-await", null],
     ["semi", null],
+    ["space-before-blocks", null],
     ["space-before-function-paren", null],
-    ["space-infix-ops", null]
+//    ["space-infix-ops", null] // buggy with typescript (as of 5.27.0) -- switched off below
 ]);
 
 switchOffExtensions = new Set([
     "no-unused-vars",
     "no-invalid-this",
     "no-use-before-define",
-    "no-useless-constructor"
+    "no-useless-constructor",
+    "space-infix-ops"
 ]);
 
+
 // Building eslint-typescript rules for existsing eslint rules and switching off original eslint rule
 const extendedEslintRules = Object.entries(eslintRules).reduce((extRules, [key, value]) => {
 
@@ -73,8 +93,22 @@ const extendedEslintRules = Object.entries(eslintRules).reduce((extRules, [key,
         } else {
             // If extension rule has extended options, merge with standard eslint rule options:
             if (extension !== null) {
-                value = [...value];
-                value[value.length - 1] = { ...value[value.length - 1], ...extension }
+                // 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;
@@ -117,7 +151,17 @@ module.exports = {
             }
         ],
         "@typescript-eslint/await-thenable": "error",
-        "@typescript-eslint/ban-ts-comment": "error",
+        "@typescript-eslint/ban-ts-comment": [
+            "error",
+            {
+                "ts-expect-error": "allow-with-description",
+                "ts-ignore": true,
+                "ts-nocheck": true,
+                "ts-check": false,
+                "minimumDescriptionLength": 10,
+                //"descriptionFormat": "someformathere"
+            }
+        ],
         "@typescript-eslint/ban-tslint-comment": "error", // No longer use tslint - remove rules
         "@typescript-eslint/ban-types": "off", // Can be used to ban certain types
         "@typescript-eslint/consistent-indexed-object-style": ["error", "record"],
@@ -132,6 +176,7 @@ module.exports = {
             "error",
             "interface"
         ],
+        "@typescript-eslint/consistent-type-exports": "error",
         "@typescript-eslint/consistent-type-imports": [
             "off",
             {
@@ -145,7 +190,8 @@ module.exports = {
                 "allowExpressions": true,
                 "allowTypedFunctionExpressions": true,
                 "allowHigherOrderFunctions": true,
-                "allowConciseArrowFunctionExpressionsStartingWithVoid": true
+                "allowConciseArrowFunctionExpressionsStartingWithVoid": true,
+                "allowedNames": []
             }
         ],
         "@typescript-eslint/explicit-member-accessibility": [
@@ -159,9 +205,9 @@ module.exports = {
             {
                 "allowArgumentsExplicitlyTypedAsAny": false,
                 "allowDirectConstAssertionInArrowFunctions": true,
-                "allowedNames": [],
                 "allowHigherOrderFunctions": true,
                 "allowTypedFunctionExpressions": true,
+                "allowedNames": []
             }
         ],
         "@typescript-eslint/member-delimiter-style": [
@@ -233,6 +279,7 @@ module.exports = {
                 "ignoreArrowShorthand": true
             }
         ],
+        "@typescript-eslint/no-duplicate-enum-values": "error",
         "@typescript-eslint/no-dynamic-delete": "error",
         "@typescript-eslint/no-empty-interface": "off",
         "@typescript-eslint/no-explicit-any": "off",
@@ -249,20 +296,36 @@ module.exports = {
                 "allowAsThisParameter": true
             }
         ],
+        "@typescript-eslint/no-meaningless-void-operator": "error",
         "@typescript-eslint/no-misused-new": "error",
-        "@typescript-eslint/no-misused-promises": "error",
+        "@typescript-eslint/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
+                // }
+            }
+        ],
         "@typescript-eslint/no-namespace": "off",
+        "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "error",
         "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
         "@typescript-eslint/no-non-null-assertion": "off",
-        "@typescript-eslint/no-parameter-properties": [
+        "@typescript-eslint/no-redundant-type-constituents": "error",
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-this-alias": "error",
+        "@typescript-eslint/no-throw-literal": [
             "error",
             {
-                "allows": ["private readonly", "private", "protected readonly"]
+                "allowThrowingAny": false, // Default is to allow throwing values of type any
+                "allowThrowingUnknown": true // Default is to allow throwing values of type unknown
             }
         ],
-        "@typescript-eslint/no-require-imports": "error",
-        "@typescript-eslint/no-this-alias": "error",
-        "@typescript-eslint/no-throw-literal": "error",
         "@typescript-eslint/no-type-alias": "off",
         "@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
         "@typescript-eslint/no-unnecessary-condition": "off", // allow runtime null checks etc even if reported not necessary by type system
@@ -276,8 +339,16 @@ module.exports = {
         "@typescript-eslint/no-unsafe-member-access": "error",
         "@typescript-eslint/no-unsafe-return": "error",
         "@typescript-eslint/no-unused-vars-experimental": "off", // to strict with method params...
+        "@typescript-eslint/no-useless-empty-export": "error",
         "@typescript-eslint/no-var-requires": "error",
         "@typescript-eslint/non-nullable-type-assertion-style": "error",
+        "@typescript-eslint/parameter-properties": [
+            "error",
+            {
+                "prefer": "class-property", // or "parameter-property"
+                "allow": ["private readonly", "private", "protected readonly"]
+            }
+        ],
         "@typescript-eslint/prefer-as-const": "error",
         "@typescript-eslint/prefer-enum-initializers": "error",
         "@typescript-eslint/prefer-for-of": "error",
@@ -299,10 +370,20 @@ module.exports = {
         "@typescript-eslint/restrict-plus-operands": [
             "error",
             {
-                "checkCompoundAssignments": true
+                "checkCompoundAssignments": true,
+                "allowAny": false
+            }
+        ],
+        "@typescript-eslint/restrict-template-expressions": [
+            "error",
+            {
+                "allowNumber": true,
+                "allowBoolean": false,
+                "allowAny": false,
+                "allowNullish": false,
+                "allowRegExp": false
             }
         ],
-        "@typescript-eslint/restrict-template-expressions": "error",
         "@typescript-eslint/sort-type-union-intersection-members": "off",
         "@typescript-eslint/strict-boolean-expressions": [
             "off",

package/utils/merge.js

@@ -0,0 +1,93 @@
+/**
+ *
+ * @param {any} o
+ * @returns o is {}
+ */
+ function isPlainObject(value) {
+    return  !!value &&
+        !!(value = Object.getPrototypeOf(value)) &&
+        !Object.getPrototypeOf(value);
+}
+
+/**
+ *
+ * @param {any[]} first
+ * @param {any[]} second
+ * @param {boolean} insertBoth
+ * @returns {any[]}
+ */
+ function deepMergeArrays(first, second, insertBoth = true) {
+     let result = [];
+     for (let i = 0; i < Math.max(first.length, second.length); i++) {
+        if (i < second.length) {
+            if (i < first.length) {
+                if (Array.isArray(second[i])) {
+                    if (Array.isArray(first[i])) {
+                        result.push(deepMergeArrays(first[i], second[i]));
+                    } else {
+                        result.push(first[i]);
+                    }
+                } else if (isPlainObject(second[i])) {
+                    if (isPlainObject(first[i])) {
+                        result.push(deepMergeObjects(first[i], second[i]));
+                    } else {
+                        result.push(first[i]);
+                    }
+                } else {
+                    if (first[i] === second[i] && !insertBoth) {
+                        result.push(first[i]);
+                    } else {
+                        result.push(first[i], second[i]);
+                    }
+                }
+            } else {
+                result.push(second[i]);
+            }
+        } else {
+            result.push(first[i]);
+        }
+     }
+     return result;
+}
+
+/**
+ *
+ * @param {{}} first
+ * @param {{}} second
+ * @returns {{}}
+ */
+function deepMergeObjects(first, second) {
+    const result = {};
+    const remainingKeysFromSecond = new Set(Object.keys(second));
+    for (const key of Object.keys(first)) {
+        if (remainingKeysFromSecond.has(key)) {
+            if (Array.isArray(first[key])) {
+                if (Array.isArray(second[key])) {
+                    result[key] = deepMergeArrays(first[key], second[key]);
+                } else {
+                    result[key] = first[key];
+                }
+            } else if (isPlainObject(first[key])) {
+                if (isPlainObject(second[key])) {
+                    result[key] = deepMergeObjects(first[key], second[key]);
+                } else {
+                    result[key] = first[key];
+                }
+            } else {
+                result[key] = first[key];
+            }
+            remainingKeysFromSecond.delete(key);
+        } else {
+            result[key] = first[key];
+        }
+    }
+    for (const key of Array.from(remainingKeysFromSecond)) {
+        result[key] = second[key];
+    }
+    return result;
+}
+
+module.exports = {
+    deepMergeObjects,
+    deepMergeArrays
+};