poolifier 2.0.0 → 2.2.0

package/lib/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("cluster"),r=require("events"),t=require("worker_threads"),s=require("async_hooks");function o(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var i=o(r);const n=Object.freeze({SOFT:"SOFT",HARD:"HARD"});class a extends i.default{}const h=Object.freeze({ROUND_ROBIN:"ROUND_ROBIN",LESS_RECENTLY_USED:"LESS_RECENTLY_USED"});class c{constructor(e){this.pool=e,this.nextWorkerIndex=0}choose(){const e=this.pool.workers[this.nextWorkerIndex];return this.nextWorkerIndex=this.pool.workers.length-1===this.nextWorkerIndex?0:this.nextWorkerIndex+1,e}}class k{constructor(e){this.pool=e}choose(){const e=this.pool.dynamic;let r,t=1/0;for(const[s,o]of this.pool.tasks){if(!e&&0===o)return s;o<t&&(t=o,r=s)}return r}}class l{constructor(e,r,t=h.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=r,this.workerChoiceStrategy=d.getWorkerChoiceStrategy(this.pool,t)}choose(){const e=d.findFreeWorkerBasedOnTasks(this.pool.tasks);return e||(this.pool.workers.length===this.pool.max?(this.pool.emitter.emit("busy"),this.workerChoiceStrategy.choose()):this.createDynamicallyWorkerCallback())}}class u{constructor(e,r,t=h.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=r,this.setWorkerChoiceStrategy(t)}getPoolWorkerChoiceStrategy(e=h.ROUND_ROBIN){return this.pool.dynamic?new l(this.pool,this.createDynamicallyWorkerCallback,e):d.getWorkerChoiceStrategy(this.pool,e)}setWorkerChoiceStrategy(e){this.workerChoiceStrategy=this.getPoolWorkerChoiceStrategy(e)}execute(){return this.workerChoiceStrategy.choose()}}class d{static findFreeWorkerBasedOnTasks(e){for(const[r,t]of e)if(0===t)return r;return null}static getWorkerChoiceStrategy(e,r=h.ROUND_ROBIN){switch(r){case h.ROUND_ROBIN:return new c(e);case h.LESS_RECENTLY_USED:return new k(e);default:throw new Error(`Worker choice strategy '${r}' not found`)}}}const p=()=>{};class W{constructor(e,r,t){var s;if(this.numberOfWorkers=e,this.filePath=r,this.opts=t,this.workers=[],this.tasks=new Map,this.promiseMap=new Map,this.nextMessageId=0,!this.isMain())throw new Error("Cannot start a pool from a worker!");this.checkNumberOfWorkers(this.numberOfWorkers),this.checkFilePath(this.filePath),this.setupHook();for(let e=1;e<=this.numberOfWorkers;e++)this.createAndSetupWorker();this.emitter=new a,this.workerChoiceStrategyContext=new u(this,(()=>{const e=this.createAndSetupWorker();return this.registerWorkerMessageListener(e,(r=>{const t=this.tasks.get(e);var s;s=n.HARD,(r.kill===s||0===t)&&this.destroyWorker(e)})),e}),null!==(s=t.workerChoiceStrategy)&&void 0!==s?s:h.ROUND_ROBIN)}checkFilePath(e){if(!e)throw new Error("Please specify a file with a worker implementation")}checkNumberOfWorkers(e){if(null==e)throw new Error("Cannot instantiate a pool without specifying the number of workers");if(!Number.isSafeInteger(e))throw new Error("Cannot instantiate a pool with a non integer number of workers");if(e<0)throw new Error("Cannot instantiate a pool with a negative number of workers");if(!this.dynamic&&0===e)throw new Error("Cannot instantiate a fixed pool with no worker")}get dynamic(){return!1}setWorkerChoiceStrategy(e){this.opts.workerChoiceStrategy=e,this.workerChoiceStrategyContext.setWorkerChoiceStrategy(e)}execute(e){const r=this.chooseWorker();this.increaseWorkersTask(r);const t=++this.nextMessageId,s=this.internalExecute(r,t);return this.sendToWorker(r,{data:e||{},id:t}),s}async destroy(){await Promise.all(this.workers.map((e=>this.destroyWorker(e))))}setupHook(){}increaseWorkersTask(e){this.stepWorkerNumberOfTasks(e,1)}decreaseWorkersTasks(e){this.stepWorkerNumberOfTasks(e,-1)}stepWorkerNumberOfTasks(e,r){const t=this.tasks.get(e);if(void 0===t)throw Error("Worker could not be found in tasks map");this.tasks.set(e,t+r)}removeWorker(e){const r=this.workers.indexOf(e);this.workers.splice(r,1),this.tasks.delete(e)}chooseWorker(){return this.workerChoiceStrategyContext.execute()}internalExecute(e,r){return new Promise(((t,s)=>{this.promiseMap.set(r,{resolve:t,reject:s,worker:e})}))}createAndSetupWorker(){var e,r,t;const s=this.createWorker();return s.on("error",null!==(e=this.opts.errorHandler)&&void 0!==e?e:p),s.on("online",null!==(r=this.opts.onlineHandler)&&void 0!==r?r:p),s.on("exit",null!==(t=this.opts.exitHandler)&&void 0!==t?t:p),s.once("exit",(()=>this.removeWorker(s))),this.workers.push(s),this.tasks.set(s,0),this.afterWorkerSetup(s),s}workerListener(){return e=>{if(e.id){const r=this.promiseMap.get(e.id);r&&(this.decreaseWorkersTasks(r.worker),e.error?r.reject(e.error):r.resolve(e.data),this.promiseMap.delete(e.id))}}}}class w extends W{constructor(e,r,t={}){super(e,r,t),this.opts=t}setupHook(){e.setupMaster({exec:this.filePath})}isMain(){return e.isMaster}destroyWorker(e){this.sendToWorker(e,{kill:1}),e.kill()}sendToWorker(e,r){e.send(r)}registerWorkerMessageListener(e,r){e.on("message",r)}createWorker(){return e.fork(this.opts.env)}afterWorkerSetup(e){this.registerWorkerMessageListener(e,super.workerListener())}}class m extends W{constructor(e,r,t={}){super(e,r,t)}isMain(){return t.isMainThread}async destroyWorker(e){this.sendToWorker(e,{kill:1}),await e.terminate()}sendToWorker(e,r){e.postMessage(r)}registerWorkerMessageListener(e,r){var t;null===(t=e.port2)||void 0===t||t.on("message",r)}createWorker(){return new t.Worker(this.filePath,{env:t.SHARE_ENV})}afterWorkerSetup(e){const{port1:r,port2:s}=new t.MessageChannel;e.postMessage({parent:r},[r]),e.port1=r,e.port2=s,this.registerWorkerMessageListener(e,super.workerListener())}}const g=n.SOFT;class y extends s.AsyncResource{constructor(e,r,t,s,o={killBehavior:g,maxInactiveTime:6e4}){var i,n,a;super(e),this.mainWorker=s,this.opts=o,this.killBehavior=null!==(i=this.opts.killBehavior)&&void 0!==i?i:g,this.maxInactiveTime=null!==(n=this.opts.maxInactiveTime)&&void 0!==n?n:6e4,this.async=!!this.opts.async,this.lastTask=Date.now(),this.checkFunctionInput(t),r||(this.interval=setInterval(this.checkAlive.bind(this),this.maxInactiveTime/2),this.checkAlive.bind(this)()),null===(a=this.mainWorker)||void 0===a||a.on("message",(e=>{(null==e?void 0:e.data)&&e.id?this.async?this.runInAsyncScope(this.runAsync.bind(this),this,t,e):this.runInAsyncScope(this.run.bind(this),this,t,e):e.parent?this.mainWorker=e.parent:e.kill&&(this.interval&&clearInterval(this.interval),this.emitDestroy())}))}checkFunctionInput(e){if(!e)throw new Error("fn parameter is mandatory")}getMainWorker(){if(!this.mainWorker)throw new Error("Main worker was not set");return this.mainWorker}checkAlive(){Date.now()-this.lastTask>this.maxInactiveTime&&this.sendToMainWorker({kill:this.killBehavior})}handleError(e){return e}run(e,r){try{const t=e(r.data);this.sendToMainWorker({data:t,id:r.id}),this.lastTask=Date.now()}catch(e){const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id}),this.lastTask=Date.now()}}runAsync(e,r){e(r.data).then((e=>(this.sendToMainWorker({data:e,id:r.id}),this.lastTask=Date.now(),null))).catch((e=>{const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id}),this.lastTask=Date.now()}))}}exports.AbstractWorker=y,exports.ClusterWorker=class extends y{constructor(r,t={}){super("worker-cluster-pool:pioardi",e.isMaster,r,e.worker,t)}sendToMainWorker(e){this.getMainWorker().send(e)}handleError(e){return e instanceof Error?e.message:e}},exports.DynamicClusterPool=class extends w{constructor(e,r,t,s={}){super(e,t,s),this.max=r}get dynamic(){return!0}},exports.DynamicThreadPool=class extends m{constructor(e,r,t,s={}){super(e,t,s),this.max=r}get dynamic(){return!0}},exports.FixedClusterPool=w,exports.FixedThreadPool=m,exports.KillBehaviors=n,exports.ThreadWorker=class extends y{constructor(e,r={}){super("worker-thread-pool:pioardi",t.isMainThread,e,t.parentPort,r)}sendToMainWorker(e){this.getMainWorker().postMessage(e)}},exports.WorkerChoiceStrategies=h;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("events"),t=require("cluster"),r=require("worker_threads"),s=require("async_hooks");function o(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var i,n=o(e),a=o(t);!function(e){e.FIXED="fixed",e.DYNAMIC="dynamic"}(i||(i={}));class h extends n.default{}const c=()=>{},l=Object.freeze({SOFT:"SOFT",HARD:"HARD"});const k=Object.freeze({ROUND_ROBIN:"ROUND_ROBIN",LESS_RECENTLY_USED:"LESS_RECENTLY_USED"});class u{constructor(e){this.pool=e,this.nextWorkerIndex=0}choose(){const e=this.pool.workers[this.nextWorkerIndex];return this.nextWorkerIndex=this.pool.workers.length-1===this.nextWorkerIndex?0:this.nextWorkerIndex+1,e}}class p{constructor(e){this.pool=e}choose(){const e=this.pool.type===i.DYNAMIC;let t,r=1/0;for(const[s,o]of this.pool.tasks){if(!e&&0===o)return s;o<r&&(t=s,r=o)}return t}}class d{constructor(e,t,r=k.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=t,this.workerChoiceStrategy=W.getWorkerChoiceStrategy(this.pool,r)}choose(){const e=this.pool.findFreeTasksMapEntry();return e?e[0]:this.pool.busy?this.workerChoiceStrategy.choose():this.createDynamicallyWorkerCallback()}}class y{constructor(e,t,r=k.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=t,this.setWorkerChoiceStrategy(r)}getPoolWorkerChoiceStrategy(e=k.ROUND_ROBIN){return this.pool.type===i.DYNAMIC?new d(this.pool,this.createDynamicallyWorkerCallback,e):W.getWorkerChoiceStrategy(this.pool,e)}setWorkerChoiceStrategy(e){this.workerChoiceStrategy=this.getPoolWorkerChoiceStrategy(e)}execute(){return this.workerChoiceStrategy.choose()}}class W{static getWorkerChoiceStrategy(e,t=k.ROUND_ROBIN){switch(t){case k.ROUND_ROBIN:return new u(e);case k.LESS_RECENTLY_USED:return new p(e);default:throw new Error(`Worker choice strategy '${t}' not found`)}}}class m{constructor(e,t,r){if(this.numberOfWorkers=e,this.filePath=t,this.opts=r,this.workers=[],this.tasks=new Map,this.promiseMap=new Map,this.nextMessageId=0,!this.isMain())throw new Error("Cannot start a pool from a worker!");this.checkNumberOfWorkers(this.numberOfWorkers),this.checkFilePath(this.filePath),this.checkPoolOptions(this.opts),this.setupHook();for(let e=1;e<=this.numberOfWorkers;e++)this.createAndSetupWorker();this.opts.enableEvents&&(this.emitter=new h),this.workerChoiceStrategyContext=new y(this,(()=>{const e=this.createAndSetupWorker();return this.registerWorkerMessageListener(e,(async t=>{const r=this.tasks.get(e);var s;s=l.HARD,(t.kill===s||0===r)&&await this.destroyWorker(e)})),e}),this.opts.workerChoiceStrategy)}checkFilePath(e){if(!e)throw new Error("Please specify a file with a worker implementation")}checkNumberOfWorkers(e){if(null==e)throw new Error("Cannot instantiate a pool without specifying the number of workers");if(!Number.isSafeInteger(e))throw new Error("Cannot instantiate a pool with a non integer number of workers");if(e<0)throw new Error("Cannot instantiate a pool with a negative number of workers");if(this.type===i.FIXED&&0===e)throw new Error("Cannot instantiate a fixed pool with no worker")}checkPoolOptions(e){var t,r;this.opts.workerChoiceStrategy=null!==(t=e.workerChoiceStrategy)&&void 0!==t?t:k.ROUND_ROBIN,this.opts.enableEvents=null===(r=e.enableEvents)||void 0===r||r}get numberOfRunningTasks(){return this.promiseMap.size}setWorkerChoiceStrategy(e){this.opts.workerChoiceStrategy=e,this.workerChoiceStrategyContext.setWorkerChoiceStrategy(e)}internalGetBusyStatus(){return this.numberOfRunningTasks>=this.numberOfWorkers&&!1===this.findFreeTasksMapEntry()}findFreeTasksMapEntry(){for(const[e,t]of this.tasks)if(0===t)return[e,t];return!1}execute(e){const t=this.chooseWorker(),r=++this.nextMessageId,s=this.internalExecute(t,r);return this.checkAndEmitBusy(),this.sendToWorker(t,{data:e||{},id:r}),s}async destroy(){await Promise.all(this.workers.map((e=>this.destroyWorker(e))))}setupHook(){}increaseWorkersTask(e){this.stepWorkerNumberOfTasks(e,1)}decreaseWorkersTasks(e){this.stepWorkerNumberOfTasks(e,-1)}stepWorkerNumberOfTasks(e,t){const r=this.tasks.get(e);if(void 0===r)throw Error("Worker could not be found in tasks map");this.tasks.set(e,r+t)}removeWorker(e){const t=this.workers.indexOf(e);this.workers.splice(t,1),this.tasks.delete(e)}chooseWorker(){return this.workerChoiceStrategyContext.execute()}internalExecute(e,t){return this.increaseWorkersTask(e),new Promise(((r,s)=>{this.promiseMap.set(t,{resolve:r,reject:s,worker:e})}))}createAndSetupWorker(){var e,t,r,s;const o=this.createWorker();return o.on("message",null!==(e=this.opts.messageHandler)&&void 0!==e?e:c),o.on("error",null!==(t=this.opts.errorHandler)&&void 0!==t?t:c),o.on("online",null!==(r=this.opts.onlineHandler)&&void 0!==r?r:c),o.on("exit",null!==(s=this.opts.exitHandler)&&void 0!==s?s:c),o.once("exit",(()=>this.removeWorker(o))),this.workers.push(o),this.tasks.set(o,0),this.afterWorkerSetup(o),o}workerListener(){return e=>{if(e.id){const t=this.promiseMap.get(e.id);t&&(this.decreaseWorkersTasks(t.worker),e.error?t.reject(e.error):t.resolve(e.data),this.promiseMap.delete(e.id))}}}checkAndEmitBusy(){var e;this.opts.enableEvents&&this.busy&&(null===(e=this.emitter)||void 0===e||e.emit("busy"))}}class w extends m{constructor(e,t,r={}){super(e,t,r),this.opts=r}setupHook(){a.default.setupPrimary({exec:this.filePath})}isMain(){return a.default.isPrimary}destroyWorker(e){this.sendToWorker(e,{kill:1}),e.kill()}sendToWorker(e,t){e.send(t)}registerWorkerMessageListener(e,t){e.on("message",t)}createWorker(){return a.default.fork(this.opts.env)}afterWorkerSetup(e){this.registerWorkerMessageListener(e,super.workerListener())}get type(){return i.FIXED}get busy(){return this.internalGetBusyStatus()}}class f extends m{constructor(e,t,r={}){super(e,t,r)}isMain(){return r.isMainThread}async destroyWorker(e){this.sendToWorker(e,{kill:1}),await e.terminate()}sendToWorker(e,t){e.postMessage(t)}registerWorkerMessageListener(e,t){var r;null===(r=e.port2)||void 0===r||r.on("message",t)}createWorker(){return new r.Worker(this.filePath,{env:r.SHARE_ENV})}afterWorkerSetup(e){const{port1:t,port2:s}=new r.MessageChannel;e.postMessage({parent:t},[t]),e.port1=t,e.port2=s,this.registerWorkerMessageListener(e,super.workerListener())}get type(){return i.FIXED}get busy(){return this.internalGetBusyStatus()}}const g=l.SOFT;class v extends s.AsyncResource{constructor(e,t,r,s,o={killBehavior:g,maxInactiveTime:6e4}){var i,n;super(e),this.mainWorker=s,this.opts=o,this.checkFunctionInput(r),this.checkWorkerOptions(this.opts),this.lastTaskTimestamp=Date.now(),t||(this.aliveInterval=setInterval(this.checkAlive.bind(this),(null!==(i=this.opts.maxInactiveTime)&&void 0!==i?i:6e4)/2),this.checkAlive.bind(this)()),null===(n=this.mainWorker)||void 0===n||n.on("message",(e=>{(null==e?void 0:e.data)&&e.id?this.opts.async?this.runInAsyncScope(this.runAsync.bind(this),this,r,e):this.runInAsyncScope(this.run.bind(this),this,r,e):e.parent?this.mainWorker=e.parent:e.kill&&(this.aliveInterval&&clearInterval(this.aliveInterval),this.emitDestroy())}))}checkWorkerOptions(e){var t,r;this.opts.killBehavior=null!==(t=e.killBehavior)&&void 0!==t?t:g,this.opts.maxInactiveTime=null!==(r=e.maxInactiveTime)&&void 0!==r?r:6e4,this.opts.async=!!e.async}checkFunctionInput(e){if(!e)throw new Error("fn parameter is mandatory")}getMainWorker(){if(!this.mainWorker)throw new Error("Main worker was not set");return this.mainWorker}checkAlive(){var e;Date.now()-this.lastTaskTimestamp>(null!==(e=this.opts.maxInactiveTime)&&void 0!==e?e:6e4)&&this.sendToMainWorker({kill:this.opts.killBehavior})}handleError(e){return e}run(e,t){try{const r=e(t.data);this.sendToMainWorker({data:r,id:t.id})}catch(e){const r=this.handleError(e);this.sendToMainWorker({error:r,id:t.id})}finally{this.lastTaskTimestamp=Date.now()}}runAsync(e,t){e(t.data).then((e=>(this.sendToMainWorker({data:e,id:t.id}),null))).catch((e=>{const r=this.handleError(e);this.sendToMainWorker({error:r,id:t.id})})).finally((()=>{this.lastTaskTimestamp=Date.now()})).catch(c)}}exports.AbstractWorker=v,exports.ClusterWorker=class extends v{constructor(e,t={}){super("worker-cluster-pool:poolifier",a.default.isPrimary,e,a.default.worker,t)}sendToMainWorker(e){this.getMainWorker().send(e)}handleError(e){return e instanceof Error?e.message:e}},exports.DynamicClusterPool=class extends w{constructor(e,t,r,s={}){super(e,r,s),this.max=t}get type(){return i.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.DynamicThreadPool=class extends f{constructor(e,t,r,s={}){super(e,r,s),this.max=t}get type(){return i.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.FixedClusterPool=w,exports.FixedThreadPool=f,exports.KillBehaviors=l,exports.ThreadWorker=class extends v{constructor(e,t={}){super("worker-thread-pool:poolifier",r.isMainThread,e,r.parentPort,t)}sendToMainWorker(e){this.getMainWorker().postMessage(e)}},exports.WorkerChoiceStrategies=k;

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "poolifier",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "A fast, easy to use Node.js Worker Thread Pool and Cluster Pool implementation",
   "main": "lib/index.js",
   "scripts": {
     "build": "rollup --config --environment BUILD:development",
+    "build:typedoc": "rollup --config --environment BUILD:development --environment DOCUMENTATION",
     "build:prod": "rollup --config",
     "benchmark": "npm run build && node -r source-map-support/register benchmarks/internal/bench.js",
     "benchmark:debug": "npm run build && node -r source-map-support/register --inspect benchmarks/internal/bench.js",
     "benchmark:prod": "npm run build:prod && node -r source-map-support/register benchmarks/internal/bench.js",
-    "test": "npm run build && nyc mocha --parallel 'tests/**/*.test.js'",
-    "test:debug": "npm run build && mocha --inspect 'tests/**/*.test.js'",
-    "test:prod": "npm run build:prod && nyc mocha --parallel 'tests/**/*.test.js'",
-    "sonar": "sonar-scanner",
+    "test": "npm run build && nyc mocha 'tests/**/*.test.js'",
+    "test:debug": "npm run build && mocha --no-parallel --inspect 'tests/**/*.test.js'",
+    "test:prod": "npm run build:prod && nyc mocha 'tests/**/*.test.js'",
     "coverage": "nyc report --reporter=lcov",
     "coverage:html": "nyc report --reporter=html",
     "format": "prettier --loglevel silent --write .; prettierx --write .",
@@ -23,7 +23,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pioardi/poolifier.git"
+    "url": "git+https://github.com/poolifier/poolifier.git"
   },
   "keywords": [
     "node",
@@ -55,46 +55,47 @@
   ],
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/pioardi/poolifier/issues"
+    "url": "https://github.com/poolifier/poolifier/issues"
   },
-  "homepage": "https://github.com/pioardi/poolifier#readme",
+  "homepage": "https://github.com/poolifier/poolifier#readme",
   "files": [
     "lib"
   ],
   "devDependencies": {
-    "@types/node": "^14.14.31",
-    "@typescript-eslint/eslint-plugin": "^4.15.2",
-    "@typescript-eslint/parser": "^4.15.2",
+    "@types/node": "^16.11.19",
+    "@typescript-eslint/eslint-plugin": "^5.9.0",
+    "@typescript-eslint/parser": "^5.9.0",
     "benchmark": "^2.1.4",
-    "eslint": "^7.21.0",
-    "eslint-config-standard": "^16.0.2",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsdoc": "^32.2.0",
+    "eslint": "^8.6.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-define-config": "^1.2.1",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jsdoc": "^37.5.1",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettierx": "^0.17.1",
-    "eslint-plugin-promise": "^4.3.1",
-    "eslint-plugin-spellcheck": "0.0.17",
-    "expect": "^26.6.2",
+    "eslint-plugin-prettierx": "^0.18.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-spellcheck": "0.0.19",
+    "expect": "^27.4.6",
     "microtime": "^3.0.0",
-    "mocha": "^8.3.0",
-    "mocha-lcov-reporter": "^1.3.0",
+    "mocha": "^9.1.3",
+    "mochawesome": "^7.0.1",
     "nyc": "^15.1.0",
-    "prettier": "^2.2.1",
-    "prettier-plugin-organize-imports": "^1.1.1",
-    "prettierx": "^0.17.0",
-    "rollup": "^2.40.0",
+    "prettier": "^2.5.1",
+    "prettier-plugin-organize-imports": "^2.3.4",
+    "prettierx": "^0.18.3",
+    "rollup": "^2.63.0",
     "rollup-plugin-analyzer": "^4.0.0",
     "rollup-plugin-command": "^1.1.3",
     "rollup-plugin-delete": "^2.0.0",
+    "rollup-plugin-istanbul": "^3.0.0",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "sonar-scanner": "^3.1.0",
-    "source-map-support": "^0.5.19",
-    "typedoc": "^0.20.28",
-    "typescript": "^4.2.2"
+    "rollup-plugin-ts": "^2.0.5",
+    "source-map-support": "^0.5.21",
+    "typedoc": "^0.22.10",
+    "typescript": "^4.5.4"
   },
   "engines": {
-    "node": ">=12.11.0",
-    "npm": ">=6.0.0 <7"
+    "node": ">=16.0.0",
+    "npm": ">=8.0.0"
   }
 }

package/CHANGELOG.md

@@ -1,81 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [2.0.0] - 2021-01-03
-
-### Bug fixes
-
-- Now a thread/process by default is not deleted when the task submitted take more time than maxInactiveTime configured (issue #70).
-
-### Breaking Changes
-
-- `FullPool` event is now renamed to `busy`.
-- `maxInactiveTime` on `ThreadWorker` default behavior is now changed, if you want to keep the old behavior set `killBehavior` to `KillBehaviors.HARD`.
-  _Find more details on our JSDoc._
-
-- `maxTasks` option on `FixedThreadPool` and `DynamicThreadPool` is now removed since is no more needed.
-
-- We changed some internal structures, but you shouldn't be too affected by them as these are internal changes.
-
-### Pool options types declaration merge
-
-`FixedThreadPoolOptions` and `DynamicThreadPoolOptions` type declarations have been merged to `PoolOptions<Worker>`.
-
-#### New `export` strategy
-
-```js
-// Before
-const DynamicThreadPool = require('poolifier/lib/dynamic')
-// After
-const { DynamicThreadPool } = require('poolifier/lib/dynamic')
-```
-
-But you should always prefer just using
-
-```js
-const { DynamicThreadPool } = require('poolifier')
-```
-
-#### New type definitions for input data and response
-
-For cluster worker and worker-thread pools, you can now only send and receive serializable data.  
-_This is not a limitation by poolifier but NodeJS._
-
-#### Public property replacements
-
-`numWorkers` property is now `numberOfWorkers`
-
-#### Internal (protected) properties and methods renaming
-
-These properties are not intended for end users
-
-- `id` => `nextMessageId`
-
-These methods are not intended for end users
-
-- `_chooseWorker` => `chooseWorker`
-- `_newWorker` => `createWorker`
-- `_execute` => `internalExecute`
-- `_chooseWorker` => `chooseWorker`
-- `_checkAlive` => `checkAlive`
-- `_run` => `run`
-- `_runAsync` => `runAsync`
-
-## [1.1.0] - 2020-21-05
-
-### Added
-
-- ThreadWorker support async functions as option
-- Various external library patches
-
-## [1.0.0] - 2020-24-01
-
-### Added
-
-- FixedThreadPool implementation
-- DynamicThreadPool implementation
-- WorkerThread implementation to improve developer experience

package/lib/pools/abstract-pool.d.ts

@@ -1,213 +0,0 @@
-import type { MessageValue, PromiseWorkerResponseWrapper } from '../utility-types';
-import type { IPoolInternal } from './pool-internal';
-import { PoolEmitter } from './pool-internal';
-import type { WorkerChoiceStrategy } from './selection-strategies';
-import { WorkerChoiceStrategyContext } from './selection-strategies';
-/**
- * Callback invoked if the worker raised an error.
- */
-export declare type ErrorHandler<Worker> = (this: Worker, e: Error) => void;
-/**
- * Callback invoked when the worker has started successfully.
- */
-export declare type OnlineHandler<Worker> = (this: Worker) => void;
-/**
- * Callback invoked when the worker exits successfully.
- */
-export declare type ExitHandler<Worker> = (this: Worker, code: number) => void;
-/**
- * Basic interface that describes the minimum required implementation of listener events for a pool-worker.
- */
-export interface IWorker {
-    /**
-     * Register a listener to the error event.
-     *
-     * @param event `'error'`.
-     * @param handler The error handler.
-     */
-    on(event: 'error', handler: ErrorHandler<this>): void;
-    /**
-     * Register a listener to the online event.
-     *
-     * @param event `'online'`.
-     * @param handler The online handler.
-     */
-    on(event: 'online', handler: OnlineHandler<this>): void;
-    /**
-     * Register a listener to the exit event.
-     *
-     * @param event `'exit'`.
-     * @param handler The exit handler.
-     */
-    on(event: 'exit', handler: ExitHandler<this>): void;
-    /**
-     * Register a listener to the exit event that will only performed once.
-     *
-     * @param event `'exit'`.
-     * @param handler The exit handler.
-     */
-    once(event: 'exit', handler: ExitHandler<this>): void;
-}
-/**
- * Options for a poolifier pool.
- */
-export interface PoolOptions<Worker> {
-    /**
-     * A function that will listen for error event on each worker.
-     */
-    errorHandler?: ErrorHandler<Worker>;
-    /**
-     * A function that will listen for online event on each worker.
-     */
-    onlineHandler?: OnlineHandler<Worker>;
-    /**
-     * A function that will listen for exit event on each worker.
-     */
-    exitHandler?: ExitHandler<Worker>;
-    /**
-     * The work choice strategy to use in this pool.
-     */
-    workerChoiceStrategy?: WorkerChoiceStrategy;
-}
-/**
- * Base class containing some shared logic for all poolifier pools.
- *
- * @template Worker Type of worker which manages this pool.
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-export declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Response = unknown> implements IPoolInternal<Worker, Data, Response> {
-    readonly numberOfWorkers: number;
-    readonly filePath: string;
-    readonly opts: PoolOptions<Worker>;
-    /** @inheritdoc */
-    readonly workers: Worker[];
-    /** @inheritdoc */
-    readonly tasks: Map<Worker, number>;
-    /** @inheritdoc */
-    readonly emitter: PoolEmitter;
-    /**
-     * The promise map.
-     *
-     * - `key`: This is the message ID of each submitted task.
-     * - `value`: An object that contains the worker, the resolve function and the reject function.
-     *
-     * When we receive a message from the worker we get a map entry and resolve/reject the promise based on the message.
-     */
-    protected promiseMap: Map<number, PromiseWorkerResponseWrapper<Worker, Response>>;
-    /**
-     * ID of the next message.
-     */
-    protected nextMessageId: number;
-    /**
-     * Worker choice strategy instance implementing the worker choice algorithm.
-     *
-     * Default to a strategy implementing a round robin algorithm.
-     */
-    protected workerChoiceStrategyContext: WorkerChoiceStrategyContext<Worker, Data, Response>;
-    /**
-     * Constructs a new poolifier pool.
-     *
-     * @param numberOfWorkers Number of workers that this pool should manage.
-     * @param filePath Path to the worker-file.
-     * @param opts Options for the pool.
-     */
-    constructor(numberOfWorkers: number, filePath: string, opts: PoolOptions<Worker>);
-    private checkFilePath;
-    private checkNumberOfWorkers;
-    /** @inheritdoc */
-    get dynamic(): boolean;
-    /** @inheritdoc */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
-    /** @inheritdoc */
-    execute(data: Data): Promise<Response>;
-    /** @inheritdoc */
-    destroy(): Promise<void>;
-    /**
-     * Shut down given worker.
-     *
-     * @param worker A worker within `workers`.
-     */
-    protected abstract destroyWorker(worker: Worker): void | Promise<void>;
-    /**
-     * Setup hook that can be overridden by a Poolifier pool implementation
-     * to run code before workers are created in the abstract constructor.
-     */
-    protected setupHook(): void;
-    /**
-     * Should return whether the worker is the main worker or not.
-     */
-    protected abstract isMain(): boolean;
-    /**
-     * Increase the number of tasks that the given workers has done.
-     *
-     * @param worker Worker whose tasks are increased.
-     */
-    protected increaseWorkersTask(worker: Worker): void;
-    /**
-     * Decrease the number of tasks that the given workers has done.
-     *
-     * @param worker Worker whose tasks are decreased.
-     */
-    protected decreaseWorkersTasks(worker: Worker): void;
-    /**
-     * Step the number of tasks that the given workers has done.
-     *
-     * @param worker Worker whose tasks are set.
-     * @param step Worker number of tasks step.
-     */
-    private stepWorkerNumberOfTasks;
-    /**
-     * Removes the given worker from the pool.
-     *
-     * @param worker Worker that will be removed.
-     */
-    protected removeWorker(worker: Worker): void;
-    /**
-     * Choose a worker for the next task.
-     *
-     * The default implementation uses a round robin algorithm to distribute the load.
-     *
-     * @returns Worker.
-     */
-    protected chooseWorker(): Worker;
-    /**
-     * Send a message to the given worker.
-     *
-     * @param worker The worker which should receive the message.
-     * @param message The message.
-     */
-    protected abstract sendToWorker(worker: Worker, message: MessageValue<Data>): void;
-    /**
-     * Register a listener callback on a given worker.
-     *
-     * @param worker A worker.
-     * @param listener A message listener callback.
-     */
-    protected abstract registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
-    protected internalExecute(worker: Worker, messageId: number): Promise<Response>;
-    /**
-     * Returns a newly created worker.
-     */
-    protected abstract createWorker(): Worker;
-    /**
-     * Function that can be hooked up when a worker has been newly created and moved to the workers registry.
-     *
-     * Can be used to update the `maxListeners` or binding the `main-worker`<->`worker` connection if not bind by default.
-     *
-     * @param worker The newly created worker.
-     */
-    protected abstract afterWorkerSetup(worker: Worker): void;
-    /**
-     * Creates a new worker for this pool and sets it up completely.
-     *
-     * @returns New, completely set up worker.
-     */
-    protected createAndSetupWorker(): Worker;
-    /**
-     * This function is the listener registered for each worker.
-     *
-     * @returns The listener function to execute when a message is sent from a worker.
-     */
-    protected workerListener(): (message: MessageValue<Response>) => void;
-}

package/lib/pools/cluster/dynamic.d.ts

@@ -1,28 +0,0 @@
-import type { ClusterPoolOptions } from './fixed';
-import { FixedClusterPool } from './fixed';
-/**
- * A cluster pool with a dynamic number of workers, but a guaranteed minimum number of workers.
- *
- * This cluster pool creates new workers when the others are busy, up to the maximum number of workers.
- * When the maximum number of workers is reached, an event is emitted. If you want to listen to this event, use the pool's `emitter`.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- *
- * @author [Christopher Quadflieg](https://github.com/Shinigami92)
- * @since 2.0.0
- */
-export declare class DynamicClusterPool<Data = unknown, Response = unknown> extends FixedClusterPool<Data, Response> {
-    readonly max: number;
-    /**
-     * Constructs a new poolifier dynamic cluster pool.
-     *
-     * @param min Minimum number of workers which are always active.
-     * @param max Maximum number of workers that can be created by this pool.
-     * @param filePath Path to an implementation of a `ClusterWorker` file, which can be relative or absolute.
-     * @param opts Options for this dynamic cluster pool. Default: `{}`
-     */
-    constructor(min: number, max: number, filePath: string, opts?: ClusterPoolOptions);
-    /** @inheritdoc */
-    get dynamic(): boolean;
-}

package/lib/pools/cluster/fixed.d.ts

@@ -1,49 +0,0 @@
-/// <reference types="node" />
-import { Worker } from 'cluster';
-import type { MessageValue } from '../../utility-types';
-import type { PoolOptions } from '../abstract-pool';
-import { AbstractPool } from '../abstract-pool';
-/**
- * Options for a poolifier cluster pool.
- */
-export interface ClusterPoolOptions extends PoolOptions<Worker> {
-    /**
-     * Key/value pairs to add to worker process environment.
-     *
-     * @see https://nodejs.org/api/cluster.html#cluster_cluster_fork_env
-     */
-    env?: any;
-}
-/**
- * A cluster pool with a fixed number of workers.
- *
- * It is possible to perform tasks in sync or asynchronous mode as you prefer.
- *
- * This pool selects the workers in a round robin fashion.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- *
- * @author [Christopher Quadflieg](https://github.com/Shinigami92)
- * @since 2.0.0
- */
-export declare class FixedClusterPool<Data = unknown, Response = unknown> extends AbstractPool<Worker, Data, Response> {
-    readonly opts: ClusterPoolOptions;
-    /**
-     * Constructs a new poolifier fixed cluster pool.
-     *
-     * @param numberOfWorkers Number of workers for this pool.
-     * @param filePath Path to an implementation of a `ClusterWorker` file, which can be relative or absolute.
-     * @param opts Options for this fixed cluster pool. Default: `{}`
-     */
-    constructor(numberOfWorkers: number, filePath: string, opts?: ClusterPoolOptions);
-    protected setupHook(): void;
-    protected isMain(): boolean;
-    /** @inheritdoc */
-    destroyWorker(worker: Worker): void;
-    protected sendToWorker(worker: Worker, message: MessageValue<Data>): void;
-    /** @inheritdoc */
-    registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
-    protected createWorker(): Worker;
-    protected afterWorkerSetup(worker: Worker): void;
-}

package/lib/pools/pool-internal.d.ts

@@ -1,47 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
-import type { IWorker } from './abstract-pool';
-import type { IPool } from './pool';
-/**
- * Internal poolifier pool emitter.
- */
-export declare class PoolEmitter extends EventEmitter {
-}
-/**
- * Internal contract definition for a poolifier pool.
- *
- * @template Worker Type of worker which manages this pool.
- * @template Data Type of data sent to the worker.
- * @template Response Type of response of execution.
- */
-export interface IPoolInternal<Worker extends IWorker, Data = unknown, Response = unknown> extends IPool<Data, Response> {
-    /**
-     * List of currently available workers.
-     */
-    readonly workers: Worker[];
-    /**
-     * The tasks map.
-     *
-     * - `key`: The `Worker`
-     * - `value`: Number of tasks currently in progress on the worker.
-     */
-    readonly tasks: Map<Worker, number>;
-    /**
-     * Emitter on which events can be listened to.
-     *
-     * Events that can currently be listened to:
-     *
-     * - `'busy'`
-     */
-    readonly emitter: PoolEmitter;
-    /**
-     * Whether the pool is dynamic or not.
-     *
-     * If it is dynamic, it provides the `max` property.
-     */
-    readonly dynamic: boolean;
-    /**
-     * Maximum number of workers that can be created by this pool.
-     */
-    readonly max?: number;
-}

package/lib/pools/pool.d.ts

@@ -1,26 +0,0 @@
-import type { WorkerChoiceStrategy } from './selection-strategies';
-/**
- * Contract definition for a poolifier pool.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-export interface IPool<Data = unknown, Response = unknown> {
-    /**
-     * Perform the task specified in the constructor with the data parameter.
-     *
-     * @param data The input for the specified task. This can only be serializable data.
-     * @returns Promise that will be resolved when the task is successfully completed.
-     */
-    execute(data: Data): Promise<Response>;
-    /**
-     * Shut down every current worker in this pool.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Set the worker choice strategy in this pool.
-     *
-     * @param workerChoiceStrategy The worker choice strategy.
-     */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
-}

package/lib/pools/selection-strategies.d.ts

@@ -1,58 +0,0 @@
-import type { IWorker } from './abstract-pool';
-import type { IPoolInternal } from './pool-internal';
-/**
- * Enumeration of worker choice strategies.
- */
-export declare const WorkerChoiceStrategies: Readonly<{
-    /**
-     * Round robin worker selection strategy.
-     */
-    readonly ROUND_ROBIN: "ROUND_ROBIN";
-    /**
-     * Less recently used worker selection strategy.
-     */
-    readonly LESS_RECENTLY_USED: "LESS_RECENTLY_USED";
-}>;
-/**
- * Worker choice strategy.
- */
-export declare type WorkerChoiceStrategy = keyof typeof WorkerChoiceStrategies;
-/**
- * The worker choice strategy context.
- *
- * @template Worker Type of worker.
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-export declare class WorkerChoiceStrategyContext<Worker extends IWorker, Data, Response> {
-    private readonly pool;
-    private createDynamicallyWorkerCallback;
-    private workerChoiceStrategy;
-    /**
-     * Worker choice strategy context constructor.
-     *
-     * @param pool The pool instance.
-     * @param createDynamicallyWorkerCallback The worker creation callback for dynamic pool.
-     * @param workerChoiceStrategy The worker choice strategy.
-     */
-    constructor(pool: IPoolInternal<Worker, Data, Response>, createDynamicallyWorkerCallback: () => Worker, workerChoiceStrategy?: WorkerChoiceStrategy);
-    /**
-     * Get the worker choice strategy instance specific to the pool type.
-     *
-     * @param workerChoiceStrategy The worker choice strategy.
-     * @returns The worker choice strategy instance for the pool type.
-     */
-    private getPoolWorkerChoiceStrategy;
-    /**
-     * Set the worker choice strategy to use in the context.
-     *
-     * @param workerChoiceStrategy The worker choice strategy to set.
-     */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
-    /**
-     * Choose a worker with the underlying selection strategy.
-     *
-     * @returns The chosen one.
-     */
-    execute(): Worker;
-}