@josundt/eslint-config 4.6.1 → 4.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josundt/eslint-config",
-  "version": "4.6.1",
+  "version": "4.7.3",
   "description": "ESLint ruleset with required plugins for josundt TypeScript projects",
   "main": "index.js",
   "scripts": {
@@ -23,20 +23,21 @@
   "license": "ISC",
   "files": [
     "*.js",
-    "rules/**/*.js"
+    "rules/**/*.js",
+    "utils/**/*.js"
   ],
   "peerDependencies": {
-    "typescript": ">=4.6.2"
+    "typescript": ">=4.7.2"
   },
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "5.14.0",
-    "@typescript-eslint/parser": "5.14.0",
-    "eslint": "8.10.0",
-    "eslint-import-resolver-typescript": "2.5.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.25.4",
+    "eslint-plugin-import": "2.26.0",
     "eslint-plugin-jasmine": "4.1.3",
-    "eslint-plugin-jsdoc": "37.9.7",
-    "eslint-plugin-unicorn": "41.0.0"
+    "eslint-plugin-jsdoc": "39.3.2",
+    "eslint-plugin-unicorn": "42.0.0"
   }
 }

package/rules/eslint.js

@@ -141,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",
@@ -205,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",
@@ -226,7 +231,8 @@ module.exports = {
             "error",
             {
                 "vars": "all",
-                "args": "none"
+                "args": "none",
+                "destructuredArrayIgnorePattern": "^_"
             }
         ],
         "no-use-before-define": "error",

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,4 +1,6 @@
-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.
@@ -28,8 +30,9 @@ 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],
@@ -60,16 +63,18 @@ const extensions = new Map([
     ["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]) => {
 
@@ -88,13 +93,21 @@ 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];
+                // 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") {
-                    value[value.length - 1] = { ...value[value.length - 1], ...extension }
+                    // 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") {
-                    value[value.length - 1] = { ...extension(value[value.length - 1]) };
+                    const [, ...options] = value;
+                    value[value.length - 1] = { ...extension(...options) };
                 }
             }
             // Add extension rule value with the @typescript-eslint key prefix
@@ -138,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"],
@@ -256,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",
@@ -278,6 +302,7 @@ module.exports = {
             "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
@@ -291,12 +316,6 @@ module.exports = {
         "@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": [
-            "error",
-            {
-                "allows": ["private readonly", "private", "protected readonly"]
-            }
-        ],
         "@typescript-eslint/no-redundant-type-constituents": "error",
         "@typescript-eslint/no-require-imports": "error",
         "@typescript-eslint/no-this-alias": "error",
@@ -323,6 +342,13 @@ module.exports = {
         "@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",

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
+};