node-pluginsmanager-plugin 4.8.8 → 5.0.0

package/lib/cjs/main.d.cts

@@ -0,0 +1,29 @@
+import { checkExists, checkExistsSync } from "./checkers/ReferenceError/checkExists";
+import { checkBoolean, checkBooleanSync } from "./checkers/TypeError/checkBoolean";
+import { checkFunction, checkFunctionSync } from "./checkers/TypeError/checkFunction";
+import { checkNumber, checkNumberSync } from "./checkers/TypeError/checkNumber";
+import { checkObject, checkObjectSync } from "./checkers/TypeError/checkObject";
+import { checkString, checkStringSync } from "./checkers/TypeError/checkString";
+import { checkArray, checkArraySync } from "./checkers/TypeError/checkArray";
+import { checkInteger, checkIntegerSync } from "./checkers/TypeError/checkInteger";
+import { checkNonEmptyArray, checkNonEmptyArraySync } from "./checkers/RangeError/checkNonEmptyArray";
+import { checkNonEmptyInteger, checkNonEmptyIntegerSync } from "./checkers/RangeError/checkNonEmptyInteger";
+import { checkNonEmptyNumber, checkNonEmptyNumberSync } from "./checkers/RangeError/checkNonEmptyNumber";
+import { checkNonEmptyObject, checkNonEmptyObjectSync } from "./checkers/RangeError/checkNonEmptyObject";
+import { checkNonEmptyString, checkNonEmptyStringSync } from "./checkers/RangeError/checkNonEmptyString";
+import { checkNumberBetween, checkNumberBetweenSync } from "./checkers/RangeError/checkNumberBetween";
+import { checkObjectLength, checkObjectLengthSync } from "./checkers/RangeError/checkObjectLength";
+import { checkObjectLengthBetween, checkObjectLengthBetweenSync } from "./checkers/RangeError/checkObjectLengthBetween";
+import { checkStringLength, checkStringLengthSync } from "./checkers/RangeError/checkStringLength";
+import { checkStringLengthBetween, checkStringLengthBetweenSync } from "./checkers/RangeError/checkStringLengthBetween";
+import { checkIntegerBetween, checkIntegerBetweenSync } from "./checkers/RangeError/checkIntegerBetween";
+import { checkArrayLength, checkArrayLengthSync } from "./checkers/RangeError/checkArrayLength";
+import { checkArrayLengthBetween, checkArrayLengthBetweenSync } from "./checkers/RangeError/checkArrayLengthBetween";
+export { checkExists, checkExistsSync, checkBoolean, checkBooleanSync, checkFunction, checkFunctionSync, checkNumber, checkNumberSync, checkObject, checkObjectSync, checkString, checkStringSync, checkArray, checkArraySync, checkInteger, checkIntegerSync, checkNonEmptyArray, checkNonEmptyArraySync, checkNonEmptyInteger, checkNonEmptyIntegerSync, checkNonEmptyNumber, checkNonEmptyNumberSync, checkNonEmptyObject, checkNonEmptyObjectSync, checkNonEmptyString, checkNonEmptyStringSync, checkNumberBetween, checkNumberBetweenSync, checkObjectLength, checkObjectLengthSync, checkObjectLengthBetween, checkObjectLengthBetweenSync, checkStringLength, checkStringLengthSync, checkStringLengthBetween, checkStringLengthBetweenSync, checkIntegerBetween, checkIntegerBetweenSync, checkArrayLength, checkArrayLengthSync, checkArrayLengthBetween, checkArrayLengthBetweenSync };
+import DescriptorUser from "./components/DescriptorUser";
+import Mediator from "./components/Mediator";
+import MediatorUser from "./components/MediatorUser";
+import Orchestrator from "./components/Orchestrator";
+import Server from "./components/Server";
+import NotFoundError from "./components/NotFoundError";
+export { DescriptorUser, Mediator, MediatorUser, Orchestrator, Server, NotFoundError };

package/lib/cjs/utils/cleanSendedError.d.ts

@@ -0,0 +1 @@
+export default function cleanSendedError(data: any): string;

package/lib/cjs/utils/cleanSendedError.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function cleanSendedError(data) {
+    if ("object" === typeof data) {
+        if (data instanceof Error) {
+            return data.message;
+        }
+        else if (data.message) {
+            return data.message instanceof Error ? data.message.message : data.message;
+        }
+        else if (data.error) { // 1 level recursive for "error" data (avoid too deep recursive analyse)
+            if (data.error instanceof Error) {
+                return data.error.message;
+            }
+            else if (data.error.message) {
+                return data.error.message instanceof Error ? data.error.message.message : data.error.message;
+            }
+            else {
+                return data.error;
+            }
+        }
+        else if (data.err) { // 1 level recursive for "err" data (avoid too deep recursive analyse)
+            if (data.err instanceof Error) {
+                return data.err.message;
+            }
+            else if (data.err.message) {
+                return data.err.message instanceof Error ? data.err.message.message : data.err.message;
+            }
+            else {
+                return data.err;
+            }
+        }
+        else {
+            return data;
+        }
+    }
+    else {
+        return data;
+    }
+}
+exports.default = cleanSendedError;
+;

package/lib/cjs/utils/descriptor/extractParams.d.ts

@@ -0,0 +1,3 @@
+export default function extractParams(patternPath: string, realPath: string): {
+    [key: string]: any;
+};

package/lib/cjs/utils/descriptor/extractParams.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const removeFirstSlash_1 = __importDefault(require("../removeFirstSlash"));
+// module
+function extractParams(patternPath, realPath) {
+    const params = {};
+    const patternPathSplitted = (0, removeFirstSlash_1.default)(patternPath).split("/");
+    (0, removeFirstSlash_1.default)(realPath).split("/").forEach((p, i) => {
+        if ("{" === patternPathSplitted[i][0]) {
+            params[patternPathSplitted[i].replace("{", "").replace("}", "")] = decodeURI(p);
+        }
+    });
+    return params;
+}
+exports.default = extractParams;
+;

package/lib/cjs/utils/descriptor/extractPathMethodByOperationId.d.ts

@@ -0,0 +1,8 @@
+import { OpenApiDocument } from "express-openapi-validate";
+export declare type tMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+export interface iPathMethod {
+    "path": string;
+    "method": tMethod;
+    "operationId": string;
+}
+export default function extractPathMethodByOperationId(paths: OpenApiDocument["paths"], operationId: string): iPathMethod | null;

package/lib/cjs/utils/descriptor/extractPathMethodByOperationId.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+// module
+function extractPathMethodByOperationId(paths, operationId) {
+    // no paths in this Descriptor
+    if ("object" !== typeof paths || null === paths) {
+        return null;
+    }
+    // no operationId given
+    else if ("string" !== typeof operationId || "" === operationId.trim()) {
+        return null;
+    }
+    else {
+        let result = null;
+        for (let i = 0, pathnames = Object.keys(paths); i < pathnames.length; ++i) {
+            const pathname = pathnames[i];
+            const method = Object.keys(paths[pathname]).find((m) => {
+                return Boolean(paths[pathname][m]) && paths[pathname][m].operationId === operationId;
+            });
+            if ("undefined" !== typeof method) {
+                result = {
+                    "path": pathname,
+                    method,
+                    operationId
+                };
+                break;
+            }
+        }
+        return result;
+    }
+}
+exports.default = extractPathMethodByOperationId;
+;

package/lib/cjs/utils/descriptor/extractPattern.d.ts

@@ -0,0 +1,2 @@
+import { OpenApiDocument } from "express-openapi-validate";
+export default function extractPattern(paths: OpenApiDocument["paths"], pathname: string, method: string): string;

package/lib/cjs/utils/descriptor/extractPattern.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// locals
+const removeFirstSlash_1 = __importDefault(require("../removeFirstSlash"));
+// module
+function extractPattern(paths, pathname, method) {
+    return "object" !== typeof paths ? "" : Object.keys(paths).filter((p) => {
+        return "undefined" !== typeof paths[p][method];
+    }).find((p) => {
+        const pathnameSplitted = (0, removeFirstSlash_1.default)(pathname).split("/");
+        const pathSplitted = (0, removeFirstSlash_1.default)(p).split("/");
+        if (pathnameSplitted.length !== pathSplitted.length) {
+            return false;
+        }
+        for (let i = 0; i < pathnameSplitted.length; ++i) {
+            if ("{" !== pathSplitted[i][0] && pathSplitted[i] !== pathnameSplitted[i]) {
+                return false;
+            }
+        }
+        return true;
+    }) || "";
+}
+exports.default = extractPattern;
+;

package/lib/cjs/utils/descriptor/extractSchemaType.d.ts

@@ -0,0 +1,4 @@
+import { OpenAPIV3_1 } from "openapi-types";
+export default function extractSchemaType(schema: OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject, schemas: {
+    [key: string]: any;
+}): "boolean" | "object" | "number" | "string" | "integer" | "array";

package/lib/cjs/utils/descriptor/extractSchemaType.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function extractSchemaType(schema, schemas) {
+    let result = "string";
+    if (schema.type) {
+        result = schema.type;
+    }
+    else if (schema.$ref) {
+        const ref = schema.$ref.replace("#/components/schemas/", "");
+        if (schemas[ref] && schemas[ref].type) {
+            result = schemas[ref].type;
+        }
+    }
+    return result;
+}
+exports.default = extractSchemaType;
+;

package/lib/cjs/utils/file/checkFile.d.ts

@@ -0,0 +1 @@
+export default function checkFile(filename: string): Promise<void>;

package/lib/cjs/utils/file/checkFile.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// locals
+const isFile_1 = __importDefault(require("./isFile"));
+// module
+function checkFile(filename) {
+    return (0, isFile_1.default)(filename).then((exists) => {
+        return exists ? Promise.resolve() :
+            Promise.reject(new Error("\"" + filename + "\" does not exist."));
+    });
+}
+exports.default = checkFile;
+;

package/lib/cjs/utils/file/isFile.d.ts

@@ -0,0 +1 @@
+export default function isFile(filename: string): Promise<boolean>;

package/lib/cjs/utils/file/isFile.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// natives
+const fs_1 = require("fs");
+// locals
+const checkNonEmptyString_1 = require("../../checkers/RangeError/checkNonEmptyString");
+// module
+function isFile(filename) {
+    return (0, checkNonEmptyString_1.checkNonEmptyString)("filename", filename).then(() => {
+        return new Promise((resolve) => {
+            (0, fs_1.lstat)(filename, (err, stats) => {
+                return resolve(Boolean(!err && stats.isFile()));
+            });
+        });
+    });
+}
+exports.default = isFile;
+;

package/lib/cjs/utils/file/readJSONFile.d.ts

@@ -0,0 +1 @@
+export default function readJSONFile(file: string): Promise<any>;

package/lib/cjs/utils/file/readJSONFile.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// natives
+const fs_1 = require("fs");
+// locals
+const checkFile_1 = __importDefault(require("./checkFile"));
+// module
+function readJSONFile(file) {
+    return (0, checkFile_1.default)(file).then(() => {
+        return new Promise((resolve, reject) => {
+            (0, fs_1.readFile)(file, "utf8", (err, content) => {
+                return err ? reject(err) : resolve(content);
+            });
+        });
+    }).then((content) => {
+        return Promise.resolve(JSON.parse(content));
+    });
+}
+exports.default = readJSONFile;
+;

package/lib/cjs/utils/getUniqueID.d.ts

@@ -0,0 +1 @@
+export default function getUniqueID(): string;

package/lib/cjs/utils/getUniqueID.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// private
+// methods
+/**
+* @return {string} formated random id fragment
+*/
+function _s4() {
+    return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+}
+// module
+function getUniqueID() {
+    return _s4() + _s4() + "-" + _s4();
+}
+exports.default = getUniqueID;
+;

package/lib/cjs/utils/removeFirstSlash.d.ts

@@ -0,0 +1 @@
+export default function removeFirstSlash(path: string): string;

package/lib/cjs/utils/removeFirstSlash.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function removeFirstSlash(path) {
+    return "string" === typeof path && "/" === path[0] ? path.substring(1, path.length) : String(path);
+}
+exports.default = removeFirstSlash;
+;

package/lib/cjs/utils/request/extractBody.d.ts

@@ -0,0 +1,7 @@
+import { iIncomingMessage } from "../../components/Server";
+interface iResult {
+    "value": string;
+    "parsed": any;
+}
+export default function extractBody(req: iIncomingMessage): Promise<iResult>;
+export {};

package/lib/cjs/utils/request/extractBody.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const checkInteger_1 = require("../../checkers/TypeError/checkInteger");
+const checkFunction_1 = require("../../checkers/TypeError/checkFunction");
+const checkNonEmptyObject_1 = require("../../checkers/RangeError/checkNonEmptyObject");
+// module
+function extractBody(req) {
+    return (0, checkNonEmptyObject_1.checkNonEmptyObject)("req", req).then(() => {
+        return (0, checkFunction_1.checkFunction)("req.on", req.on);
+    }).then(() => {
+        return (0, checkNonEmptyObject_1.checkNonEmptyObject)("req.headers", req.headers);
+    }).then(() => {
+        return (0, checkInteger_1.checkInteger)("req.headers[\"content-length\"]", req.headers["content-length"]);
+    }).then(() => {
+        return new Promise((resolve, reject) => {
+            let queryData = "";
+            req.on("data", (data) => {
+                queryData += data.toString("utf8");
+            }).on("end", () => {
+                if ("" === queryData || "null" === queryData) {
+                    resolve({
+                        "value": "",
+                        "parsed": {}
+                    });
+                }
+                else {
+                    req.headers["content-length"] = parseInt(req.headers["content-length"], 10);
+                    if (req.headers["content-length"] !== Buffer.byteLength(queryData)) {
+                        reject(new Error("\"Content-Length\" header (" + Buffer.byteLength(queryData) + ")" +
+                            " is not as expected (" + req.headers["content-length"] + ")." +
+                            " Do not forget the fact that it is a 8-bit bytes number."));
+                    }
+                    else {
+                        try {
+                            resolve({
+                                "value": queryData,
+                                "parsed": JSON.parse(queryData)
+                            });
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    }
+                }
+            });
+        });
+    });
+}
+exports.default = extractBody;
+;

package/lib/cjs/utils/request/extractCookies.d.ts

@@ -0,0 +1,4 @@
+import { iIncomingMessage } from "../../components/Server";
+export default function extractCookies(req: iIncomingMessage): {
+    [key: string]: string;
+};

package/lib/cjs/utils/request/extractCookies.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// private
+// methods
+/**
+* Extract cookies from string
+* @param {string} cookies: data string to parse
+* @returns {object} Parsed data
+*/
+function _parseCookies(cookies) {
+    if ("string" !== typeof cookies) {
+        return {};
+    }
+    else {
+        const result = {};
+        cookies.split(";").forEach((cookie) => {
+            const parts = cookie.split("=");
+            result[parts[0]] = decodeURI(parts[1]);
+        });
+        return result;
+    }
+}
+// module
+function extractCookies(req) {
+    if ("object" !== typeof req) {
+        return {};
+    }
+    else if ("object" === typeof req.cookies) {
+        return req.cookies;
+    }
+    else if (req.headers) {
+        if (req.headers.cookie) {
+            return _parseCookies(req.headers.cookie);
+        }
+        else if (req.headers.Cookie) {
+            return _parseCookies(req.headers.Cookie);
+        }
+        else if (req.headers.cookies) {
+            return _parseCookies(req.headers.cookies);
+        }
+        else if (req.headers.Cookies) {
+            return _parseCookies(req.headers.Cookies);
+        }
+        else {
+            return {};
+        }
+    }
+    else {
+        return {};
+    }
+}
+exports.default = extractCookies;
+;

package/lib/cjs/utils/request/extractIp.d.ts

@@ -0,0 +1 @@
+export default function extractIp(req: any): string;

package/lib/cjs/utils/request/extractIp.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function extractIp(req) {
+    if ("object" !== typeof req) {
+        return "";
+    }
+    else {
+        let result = "";
+        if (req.ip) {
+            result = req.ip;
+        }
+        else if (req.headers && req.headers["x-forwarded-for"]) {
+            result = req.headers["x-forwarded-for"].split(",").pop();
+        }
+        else if (req.socket && req.socket.remoteAddress) {
+            result = req.socket.remoteAddress;
+        }
+        else if (req.connection) {
+            if (req.connection.remoteAddress) {
+                result = req.connection.remoteAddress;
+            }
+            else if (req.connection.socket && req.connection.socket.remoteAddress) {
+                result = req.connection.socket.remoteAddress;
+            }
+            else {
+                result = "";
+            }
+        }
+        else {
+            result = "";
+        }
+        return result
+            .replace("::ffff:", "")
+            .replace("localhost", "127.0.0.1")
+            .replace("::1", "127.0.0.1");
+    }
+}
+exports.default = extractIp;
+;

package/lib/cjs/utils/send.d.ts

@@ -0,0 +1,2 @@
+import { iIncomingMessage, iServerResponse } from "../components/Server";
+export default function send(req: iIncomingMessage, res: iServerResponse, code: number, content: any, apiVersion: string, cors: boolean): Promise<void>;

package/lib/cjs/utils/send.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+function send(req, res, code, content, apiVersion, cors) {
+    return new Promise((resolve) => {
+        // formate content
+        if ("undefined" !== typeof content) {
+            res.body = JSON.stringify(content);
+        }
+        // force data for checking
+        res.statusCode = code;
+        res.headers = Object.assign({
+            "Content-Type": "application/json; charset=utf-8",
+            "Content-Length": res.body ? Buffer.byteLength(res.body) : 0,
+            "Status-Code-Url-Cat": "https://http.cat/" + code,
+            "API-Version": apiVersion
+        }, cors ? {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Credentials": true,
+            "Access-Control-Allow-Methods": req.headers["access-control-request-method"] ? req.headers["access-control-request-method"] : [
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+                "PATCH",
+                "OPTIONS"
+            ].join(", "),
+            "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] ? req.headers["access-control-request-headers"] : [
+                "Origin",
+                "Accept",
+                "Accept-Version",
+                "Content-Length",
+                "Content-MD5",
+                "Content-Type",
+                "Date",
+                "X-Api-Version",
+                "X-File-Name",
+                "X-CSRF-Token",
+                "X-Requested-With"
+            ].join(", ")
+        } : {});
+        // send data
+        res.writeHead(res.statusCode, res.headers);
+        if (res.body) {
+            res.end(res.body, "utf-8", () => {
+                resolve();
+            });
+        }
+        else {
+            res.end(() => {
+                resolve();
+            });
+        }
+    });
+}
+exports.default = send;
+;

package/lib/cjs/utils/serverCodes.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    OK: number;
+    OK_PUT: number;
+    OK_NO_CONTENT: number;
+    MISSING_PARAMETER: number;
+    WRONG_TYPE_PARAMETER: number;
+    EMPTY_OR_RANGE_OR_ENUM_PARAMETER: number;
+    JSON_PARSE: number;
+    NOT_FOUND: number;
+    MISSING_HEADER: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+};
+export default _default;

package/lib/cjs/utils/serverCodes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    "OK": 200,
+    "OK_PUT": 201,
+    "OK_NO_CONTENT": 204,
+    "MISSING_PARAMETER": 400,
+    "WRONG_TYPE_PARAMETER": 400,
+    "EMPTY_OR_RANGE_OR_ENUM_PARAMETER": 400,
+    "JSON_PARSE": 400,
+    "NOT_FOUND": 404,
+    "MISSING_HEADER": 411,
+    "INTERNAL_SERVER_ERROR": 500,
+    "NOT_IMPLEMENTED": 501
+};

package/package.json

@@ -1,23 +1,40 @@
 {
   "name": "node-pluginsmanager-plugin",
-  "version": "4.8.8",
+  "version": "5.0.0",
   "description": "An abstract parent plugin for node-pluginsmanager",
-  "main": "lib/main.js",
-  "typings": "lib/index.d.ts",
+
+  "type": "commonjs",
+  "typings": "./lib/cjs/main.d.cts",
+  "main": "./lib/cjs/main.cjs",
+
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./lib/cjs/main.d.cts",
+        "default": "./lib/cjs/main.cjs"
+      }
+    }
+  },
+
   "scripts": {
-    "lint": "npx eslint ./lib/**/*.js ./test/**/*.js",
+
     "check-updates": "npx check-version-modules",
-    "unit-tests": "npx nyc --reporter=html --reporter=text mocha",
-    "tests": "npm run-script lint && npm run-script check-updates && npm run-script unit-tests",
+
+    "compile": "npx tsc --project \"./tsconfig.json\"",
+
+    "unit-tests": "npm run compile && npx nyc --reporter=html --reporter=text mocha",
+    "tests": "npm run-script check-updates && npm run-script unit-tests",
     "ci": "npm run-script tests && npx nyc report --reporter=text-lcov | coveralls"
+
   },
+
   "files": [
     "/lib"
   ],
+
   "husky": {
     "hooks": {
-      "pre-commit": "npm run-script lint",
-      "pre-push": "npm run-script tests"
+		"pre-push": "npm run-script tests"
     }
   },
   "repository": {
@@ -36,24 +53,26 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "10.1.0",
-    "express-openapi-validate": "0.6.1"
+    "express-openapi-validate": "0.6.1",
+    "uniqid": "5.4.0"
   },
   "devDependencies": {
-    "@types/node": "17.0.36",
+    "@types/express": "4.17.13",
+    "@types/node": "18.0.0",
     "@types/socket.io": "3.0.2",
+    "@types/uniqid": "5.3.2",
     "@types/ws": "8.5.3",
     "check-version-modules": "1.3.5",
     "coveralls": "3.1.1",
     "colors": "1.4.0",
-    "eslint": "8.16.0",
     "express": "4.18.1",
     "husky": "8.0.1",
     "mocha": "10.0.0",
     "nyc": "15.1.0",
     "socket.io": "4.5.1",
     "socket.io-client": "4.5.1",
-    "typescript": "4.7.2",
-    "ws": "8.7.0"
+    "typescript": "4.7.4",
+    "ws": "8.8.0"
   },
   "homepage": "https://github.com/Psychopoulet/node-pluginsmanager-plugin#readme",
   "engines": {