poolifier 2.3.7 → 2.3.8

package/lib/index.js

@@ -1 +1 @@
-"use strict";var e,r=require("cluster"),t=require("events"),s=require("os"),o=require("worker_threads"),i=require("async_hooks");!function(e){e.FIXED="fixed",e.DYNAMIC="dynamic"}(e||(e={}));const n=()=>{},a={},h=Object.freeze({SOFT:"SOFT",HARD:"HARD"});class k extends t{}const c=Object.freeze({ROUND_ROBIN:"ROUND_ROBIN",LESS_RECENTLY_USED:"LESS_RECENTLY_USED",FAIR_SHARE:"FAIR_SHARE",WEIGHTED_ROUND_ROBIN:"WEIGHTED_ROUND_ROBIN"});class u{constructor(r){this.pool=r,this.isDynamicPool=this.pool.type===e.DYNAMIC,this.requiredStatistics={runTime:!1}}}class l extends u{constructor(){super(...arguments),this.requiredStatistics={runTime:!0},this.workerLastVirtualTaskTimestamp=new Map}reset(){return this.workerLastVirtualTaskTimestamp.clear(),!0}choose(){let e,r=1/0;for(const t of this.pool.workers){this.computeWorkerLastVirtualTaskTimestamp(t);const s=this.workerLastVirtualTaskTimestamp.get(t)?.end??0;s<r&&(r=s,e=t)}return e}computeWorkerLastVirtualTaskTimestamp(e){const r=Math.max(Date.now(),this.workerLastVirtualTaskTimestamp.get(e)?.end??-1/0);this.workerLastVirtualTaskTimestamp.set(e,{start:r,end:r+(this.pool.getWorkerAverageTasksRunTime(e)??0)})}}class p extends u{reset(){return!0}choose(){let e,r=1/0;for(const t of this.pool.workers){const s=this.pool.getWorkerRunningTasks(t);if(!this.isDynamicPool&&0===s)return t;s<r&&(e=t,r=s)}return e}}class g extends u{constructor(){super(...arguments),this.nextWorkerIndex=0}reset(){return this.nextWorkerIndex=0,!0}choose(){const e=this.pool.workers[this.nextWorkerIndex];return this.nextWorkerIndex=this.nextWorkerIndex===this.pool.workers.length-1?0:this.nextWorkerIndex+1,e}}class T extends u{constructor(e){super(e),this.requiredStatistics={runTime:!0},this.currentWorkerIndex=0,this.workersTaskRunTime=new Map,this.defaultWorkerWeight=this.computeWorkerWeight(),this.initWorkersTaskRunTime()}reset(){return this.currentWorkerIndex=0,this.workersTaskRunTime.clear(),this.initWorkersTaskRunTime(),!0}choose(){const e=this.pool.workers[this.currentWorkerIndex];this.isDynamicPool&&!this.workersTaskRunTime.has(e)&&this.initWorkerTaskRunTime(e);const r=this.workersTaskRunTime.get(e)?.runTime??0,t=this.workersTaskRunTime.get(e)?.weight??this.defaultWorkerWeight;return r<t?this.setWorkerTaskRunTime(e,t,r+(this.getWorkerVirtualTaskRunTime(e)??0)):(this.currentWorkerIndex=this.currentWorkerIndex===this.pool.workers.length-1?0:this.currentWorkerIndex+1,this.setWorkerTaskRunTime(this.pool.workers[this.currentWorkerIndex],t,0)),e}initWorkersTaskRunTime(){for(const e of this.pool.workers)this.initWorkerTaskRunTime(e)}initWorkerTaskRunTime(e){this.setWorkerTaskRunTime(e,this.defaultWorkerWeight,0)}setWorkerTaskRunTime(e,r,t){this.workersTaskRunTime.set(e,{weight:r,runTime:t})}getWorkerVirtualTaskRunTime(e){return this.pool.getWorkerAverageTasksRunTime(e)}computeWorkerWeight(){let e=0;for(const r of s.cpus()){const t=r.speed.toString().length-1;e+=1/(r.speed/Math.pow(10,t))*Math.pow(10,t)}return Math.round(e/s.cpus().length)}}function m(e,r=c.ROUND_ROBIN){switch(r){case c.ROUND_ROBIN:return new g(e);case c.LESS_RECENTLY_USED:return new p(e);case c.FAIR_SHARE:return new l(e);case c.WEIGHTED_ROUND_ROBIN:return new T(e);default:throw new Error(`Worker choice strategy '${r}' not found`)}}class W extends u{constructor(e,r,t=c.ROUND_ROBIN){super(e),this.createDynamicallyWorkerCallback=r,this.workerChoiceStrategy=m(this.pool,t),this.requiredStatistics=this.workerChoiceStrategy.requiredStatistics}reset(){return this.workerChoiceStrategy.reset()}choose(){const e=this.pool.findFreeWorker();return!1!==e?e:this.pool.busy?this.workerChoiceStrategy.choose():this.createDynamicallyWorkerCallback()}}class d{constructor(e,r,t=c.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=r,this.setWorkerChoiceStrategy(t)}getPoolWorkerChoiceStrategy(r=c.ROUND_ROBIN){return this.pool.type===e.DYNAMIC?new W(this.pool,this.createDynamicallyWorkerCallback,r):m(this.pool,r)}getWorkerChoiceStrategy(){return this.workerChoiceStrategy}setWorkerChoiceStrategy(e){this.workerChoiceStrategy?.reset(),this.workerChoiceStrategy=this.getPoolWorkerChoiceStrategy(e)}execute(){return this.workerChoiceStrategy.choose()}}class w{constructor(e,r,t){if(this.numberOfWorkers=e,this.filePath=r,this.opts=t,this.workers=[],this.workersTasksUsage=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();!0===this.opts.enableEvents&&(this.emitter=new k),this.workerChoiceStrategyContext=new d(this,(()=>{const e=this.createAndSetupWorker();return this.registerWorkerMessageListener(e,(r=>{var t;t=h.HARD,(r.kill===t||0===this.getWorkerRunningTasks(e))&&this.destroyWorker(e)})),e}),this.opts.workerChoiceStrategy)}checkFilePath(e){if(null==e||0===e.length)throw new Error("Please specify a file with a worker implementation")}checkNumberOfWorkers(r){if(null==r)throw new Error("Cannot instantiate a pool without specifying the number of workers");if(!Number.isSafeInteger(r))throw new TypeError("Cannot instantiate a pool with a non integer number of workers");if(r<0)throw new RangeError("Cannot instantiate a pool with a negative number of workers");if(this.type===e.FIXED&&0===r)throw new Error("Cannot instantiate a fixed pool with no worker")}checkPoolOptions(e){this.opts.workerChoiceStrategy=e.workerChoiceStrategy??c.ROUND_ROBIN,this.opts.enableEvents=e.enableEvents??!0}get numberOfRunningTasks(){return this.promiseMap.size}getWorkerIndex(e){return this.workers.indexOf(e)}getWorkerRunningTasks(e){return this.workersTasksUsage.get(e)?.running}getWorkerAverageTasksRunTime(e){return this.workersTasksUsage.get(e)?.avgRunTime}setWorkerChoiceStrategy(e){this.opts.workerChoiceStrategy=e;for(const e of this.workers)this.resetWorkerTasksUsage(e);this.workerChoiceStrategyContext.setWorkerChoiceStrategy(e)}internalGetBusyStatus(){return this.numberOfRunningTasks>=this.numberOfWorkers&&!1===this.findFreeWorker()}findFreeWorker(){for(const e of this.workers)if(0===this.getWorkerRunningTasks(e))return e;return!1}async execute(e){const r=this.chooseWorker(),t=this.internalExecute(r,this.nextMessageId);return this.checkAndEmitBusy(),this.sendToWorker(r,{data:e??a,id:this.nextMessageId}),++this.nextMessageId,t}async destroy(){await Promise.all(this.workers.map((e=>this.destroyWorker(e))))}setupHook(){}beforePromiseWorkerResponseHook(e){this.increaseWorkerRunningTasks(e)}afterPromiseWorkerResponseHook(e,r){this.decreaseWorkerRunningTasks(r.worker),this.stepWorkerRunTasks(r.worker,1),this.updateWorkerTasksRunTime(r.worker,e.taskRunTime)}removeWorker(e){this.workers.splice(this.getWorkerIndex(e),1),this.removeWorkerTasksUsage(e)}chooseWorker(){return this.workerChoiceStrategyContext.execute()}createAndSetupWorker(){const e=this.createWorker();return e.on("message",this.opts.messageHandler??n),e.on("error",this.opts.errorHandler??n),e.on("online",this.opts.onlineHandler??n),e.on("exit",this.opts.exitHandler??n),e.once("exit",(()=>this.removeWorker(e))),this.workers.push(e),this.initWorkerTasksUsage(e),this.afterWorkerSetup(e),e}workerListener(){return e=>{if(void 0!==e.id){const r=this.promiseMap.get(e.id);void 0!==r&&(null!=e.error?r.reject(e.error):r.resolve(e.data),this.afterPromiseWorkerResponseHook(e,r),this.promiseMap.delete(e.id))}}}async internalExecute(e,r){return this.beforePromiseWorkerResponseHook(e),await new Promise(((t,s)=>{this.promiseMap.set(r,{resolve:t,reject:s,worker:e})}))}checkAndEmitBusy(){!0===this.opts.enableEvents&&this.busy&&this.emitter?.emit("busy")}increaseWorkerRunningTasks(e){this.stepWorkerRunningTasks(e,1)}decreaseWorkerRunningTasks(e){this.stepWorkerRunningTasks(e,-1)}stepWorkerRunningTasks(e,r){if(this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.running=t.running+r,this.workersTasksUsage.set(e,t)}}stepWorkerRunTasks(e,r){if(this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.run=t.run+r,this.workersTasksUsage.set(e,t)}}updateWorkerTasksRunTime(e,r){if(this.workerChoiceStrategyContext.getWorkerChoiceStrategy().requiredStatistics.runTime&&this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.runTime+=r??0,0!==t.run&&(t.avgRunTime=t.runTime/t.run),this.workersTasksUsage.set(e,t)}}checkWorkerTasksUsage(e){const r=this.workersTasksUsage.has(e);if(!r)throw new Error("Worker could not be found in workers tasks usage map");return r}initWorkerTasksUsage(e){this.workersTasksUsage.set(e,{run:0,running:0,runTime:0,avgRunTime:0})}removeWorkerTasksUsage(e){this.workersTasksUsage.delete(e)}resetWorkerTasksUsage(e){this.removeWorkerTasksUsage(e),this.initWorkerTasksUsage(e)}}class y extends w{constructor(e,r,t={}){super(e,r,t),this.opts=t}setupHook(){r.setupPrimary({...this.opts.settings,exec:this.filePath})}isMain(){return r.isPrimary}destroyWorker(e){this.sendToWorker(e,{kill:1}),e.kill()}sendToWorker(e,r){e.send(r)}registerWorkerMessageListener(e,r){e.on("message",r)}createWorker(){return r.fork(this.opts.env)}afterWorkerSetup(e){this.registerWorkerMessageListener(e,super.workerListener())}get type(){return e.FIXED}get busy(){return this.internalGetBusyStatus()}}class R extends w{constructor(e,r,t={}){super(e,r,t)}isMain(){return o.isMainThread}async destroyWorker(e){this.sendToWorker(e,{kill:1}),await e.terminate()}sendToWorker(e,r){e.postMessage(r)}registerWorkerMessageListener(e,r){e.port2?.on("message",r)}createWorker(){return new o.Worker(this.filePath,{env:o.SHARE_ENV})}afterWorkerSetup(e){const{port1:r,port2:t}=new o.MessageChannel;e.postMessage({parent:r},[r]),e.port1=r,e.port2=t,this.registerWorkerMessageListener(e,super.workerListener())}get type(){return e.FIXED}get busy(){return this.internalGetBusyStatus()}}const f=h.SOFT;class x extends i.AsyncResource{constructor(e,r,t,s,o={killBehavior:f,maxInactiveTime:6e4}){super(e),this.mainWorker=s,this.opts=o,this.checkFunctionInput(t),this.checkWorkerOptions(this.opts),this.lastTaskTimestamp=Date.now(),r||(this.aliveInterval=setInterval(this.checkAlive.bind(this),(this.opts.maxInactiveTime??6e4)/2),this.checkAlive.bind(this)()),this.mainWorker?.on("message",(e=>{this.messageListener(e,t)}))}messageListener(e,r){void 0!==e.data&&void 0!==e.id?!0===this.opts.async?this.runInAsyncScope(this.runAsync.bind(this),this,r,e):this.runInAsyncScope(this.run.bind(this),this,r,e):void 0!==e.parent?this.mainWorker=e.parent:void 0!==e.kill&&(null!=this.aliveInterval&&clearInterval(this.aliveInterval),this.emitDestroy())}checkWorkerOptions(e){this.opts.killBehavior=e.killBehavior??f,this.opts.maxInactiveTime=e.maxInactiveTime??6e4,this.opts.async=e.async??!1}checkFunctionInput(e){if(null==e)throw new Error("fn parameter is mandatory");if("function"!=typeof e)throw new TypeError("fn parameter is not a function")}getMainWorker(){if(null==this.mainWorker)throw new Error("Main worker was not set");return this.mainWorker}checkAlive(){Date.now()-this.lastTaskTimestamp>(this.opts.maxInactiveTime??6e4)&&this.sendToMainWorker({kill:this.opts.killBehavior})}handleError(e){return e}run(e,r){try{const t=Date.now(),s=e(r.data),o=Date.now()-t;this.sendToMainWorker({data:s,id:r.id,taskRunTime:o})}catch(e){const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id})}finally{this.lastTaskTimestamp=Date.now()}}runAsync(e,r){const t=Date.now();e(r.data).then((e=>{const s=Date.now()-t;return this.sendToMainWorker({data:e,id:r.id,taskRunTime:s}),null})).catch((e=>{const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id})})).finally((()=>{this.lastTaskTimestamp=Date.now()})).catch(n)}}exports.ClusterWorker=class extends x{constructor(e,t={}){super("worker-cluster-pool:poolifier",r.isPrimary,e,r.worker,t)}sendToMainWorker(e){this.getMainWorker().send(e)}handleError(e){return e instanceof Error?e.message:e}},exports.DynamicClusterPool=class extends y{constructor(e,r,t,s={}){super(e,t,s),this.max=r}get type(){return e.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.DynamicThreadPool=class extends R{constructor(e,r,t,s={}){super(e,t,s),this.max=r}get type(){return e.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.FixedClusterPool=y,exports.FixedThreadPool=R,exports.KillBehaviors=h,exports.ThreadWorker=class extends x{constructor(e,r={}){super("worker-thread-pool:poolifier",o.isMainThread,e,o.parentPort,r)}sendToMainWorker(e){this.getMainWorker().postMessage(e)}},exports.WorkerChoiceStrategies=c;
+"use strict";var e=require("cluster"),r=require("events"),t=require("os"),s=require("worker_threads"),o=require("async_hooks");const i=Object.freeze((()=>{})),n={};var a;!function(e){e.FIXED="fixed",e.DYNAMIC="dynamic"}(a||(a={}));const h=Object.freeze({SOFT:"SOFT",HARD:"HARD"});class k extends r{}const c=Object.freeze({ROUND_ROBIN:"ROUND_ROBIN",LESS_RECENTLY_USED:"LESS_RECENTLY_USED",FAIR_SHARE:"FAIR_SHARE",WEIGHTED_ROUND_ROBIN:"WEIGHTED_ROUND_ROBIN"});class u{pool;isDynamicPool;requiredStatistics={runTime:!1};constructor(e){this.pool=e,this.isDynamicPool=this.pool.type===a.DYNAMIC}}class l extends u{requiredStatistics={runTime:!0};workerLastVirtualTaskTimestamp=new Map;reset(){return this.workerLastVirtualTaskTimestamp.clear(),!0}choose(){let e,r=1/0;for(const t of this.pool.workers){this.computeWorkerLastVirtualTaskTimestamp(t);const s=this.workerLastVirtualTaskTimestamp.get(t)?.end??0;s<r&&(r=s,e=t)}return e}computeWorkerLastVirtualTaskTimestamp(e){const r=Math.max(Date.now(),this.workerLastVirtualTaskTimestamp.get(e)?.end??-1/0);this.workerLastVirtualTaskTimestamp.set(e,{start:r,end:r+(this.pool.getWorkerAverageTasksRunTime(e)??0)})}}class p extends u{reset(){return!0}choose(){let e,r=1/0;for(const t of this.pool.workers){const s=this.pool.getWorkerRunningTasks(t);if(!this.isDynamicPool&&0===s)return t;s<r&&(e=t,r=s)}return e}}class g extends u{nextWorkerIndex=0;reset(){return this.nextWorkerIndex=0,!0}choose(){const e=this.pool.workers[this.nextWorkerIndex];return this.nextWorkerIndex=this.nextWorkerIndex===this.pool.workers.length-1?0:this.nextWorkerIndex+1,e}}class m extends u{requiredStatistics={runTime:!0};currentWorkerIndex=0;defaultWorkerWeight;workersTaskRunTime=new Map;constructor(e){super(e),this.defaultWorkerWeight=this.computeWorkerWeight(),this.initWorkersTaskRunTime()}reset(){return this.currentWorkerIndex=0,this.workersTaskRunTime.clear(),this.initWorkersTaskRunTime(),!0}choose(){const e=this.pool.workers[this.currentWorkerIndex];this.isDynamicPool&&!this.workersTaskRunTime.has(e)&&this.initWorkerTaskRunTime(e);const r=this.workersTaskRunTime.get(e)?.runTime??0,t=this.workersTaskRunTime.get(e)?.weight??this.defaultWorkerWeight;return r<t?this.setWorkerTaskRunTime(e,t,r+(this.getWorkerVirtualTaskRunTime(e)??0)):(this.currentWorkerIndex=this.currentWorkerIndex===this.pool.workers.length-1?0:this.currentWorkerIndex+1,this.setWorkerTaskRunTime(this.pool.workers[this.currentWorkerIndex],t,0)),e}initWorkersTaskRunTime(){for(const e of this.pool.workers)this.initWorkerTaskRunTime(e)}initWorkerTaskRunTime(e){this.setWorkerTaskRunTime(e,this.defaultWorkerWeight,0)}setWorkerTaskRunTime(e,r,t){this.workersTaskRunTime.set(e,{weight:r,runTime:t})}getWorkerVirtualTaskRunTime(e){return this.pool.getWorkerAverageTasksRunTime(e)}computeWorkerWeight(){let e=0;for(const r of t.cpus()){const t=r.speed.toString().length-1;e+=1/(r.speed/Math.pow(10,t))*Math.pow(10,t)}return Math.round(e/t.cpus().length)}}function T(e,r=c.ROUND_ROBIN){switch(r){case c.ROUND_ROBIN:return new g(e);case c.LESS_RECENTLY_USED:return new p(e);case c.FAIR_SHARE:return new l(e);case c.WEIGHTED_ROUND_ROBIN:return new m(e);default:throw new Error(`Worker choice strategy '${r}' not found`)}}class W extends u{createDynamicallyWorkerCallback;workerChoiceStrategy;constructor(e,r,t=c.ROUND_ROBIN){super(e),this.createDynamicallyWorkerCallback=r,this.workerChoiceStrategy=T(this.pool,t),this.requiredStatistics=this.workerChoiceStrategy.requiredStatistics}reset(){return this.workerChoiceStrategy.reset()}choose(){const e=this.pool.findFreeWorker();return!1!==e?e:this.pool.busy?this.workerChoiceStrategy.choose():this.createDynamicallyWorkerCallback()}}class w{pool;createDynamicallyWorkerCallback;workerChoiceStrategy;constructor(e,r,t=c.ROUND_ROBIN){this.pool=e,this.createDynamicallyWorkerCallback=r,this.setWorkerChoiceStrategy(t)}getPoolWorkerChoiceStrategy(e=c.ROUND_ROBIN){return this.pool.type===a.DYNAMIC?new W(this.pool,this.createDynamicallyWorkerCallback,e):T(this.pool,e)}getWorkerChoiceStrategy(){return this.workerChoiceStrategy}setWorkerChoiceStrategy(e){this.workerChoiceStrategy?.reset(),this.workerChoiceStrategy=this.getPoolWorkerChoiceStrategy(e)}execute(){return this.workerChoiceStrategy.choose()}}class d{numberOfWorkers;filePath;opts;workers=[];workersTasksUsage=new Map;emitter;promiseMap=new Map;nextMessageId=0;workerChoiceStrategyContext;constructor(e,r,t){if(this.numberOfWorkers=e,this.filePath=r,this.opts=t,!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();!0===this.opts.enableEvents&&(this.emitter=new k),this.workerChoiceStrategyContext=new w(this,(()=>{const e=this.createAndSetupWorker();return this.registerWorkerMessageListener(e,(r=>{var t;t=h.HARD,(r.kill===t||0===this.getWorkerRunningTasks(e))&&this.destroyWorker(e)})),e}),this.opts.workerChoiceStrategy)}checkFilePath(e){if(null==e||0===e.length)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 TypeError("Cannot instantiate a pool with a non integer number of workers");if(e<0)throw new RangeError("Cannot instantiate a pool with a negative number of workers");if(this.type===a.FIXED&&0===e)throw new Error("Cannot instantiate a fixed pool with no worker")}checkPoolOptions(e){this.opts.workerChoiceStrategy=e.workerChoiceStrategy??c.ROUND_ROBIN,this.opts.enableEvents=e.enableEvents??!0}get numberOfRunningTasks(){return this.promiseMap.size}getWorkerIndex(e){return this.workers.indexOf(e)}getWorkerRunningTasks(e){return this.workersTasksUsage.get(e)?.running}getWorkerAverageTasksRunTime(e){return this.workersTasksUsage.get(e)?.avgRunTime}setWorkerChoiceStrategy(e){this.opts.workerChoiceStrategy=e;for(const e of this.workers)this.resetWorkerTasksUsage(e);this.workerChoiceStrategyContext.setWorkerChoiceStrategy(e)}internalGetBusyStatus(){return this.numberOfRunningTasks>=this.numberOfWorkers&&!1===this.findFreeWorker()}findFreeWorker(){for(const e of this.workers)if(0===this.getWorkerRunningTasks(e))return e;return!1}async execute(e){const r=this.chooseWorker(),t=this.internalExecute(r,this.nextMessageId);return this.checkAndEmitBusy(),this.sendToWorker(r,{data:e??n,id:this.nextMessageId}),++this.nextMessageId,t}async destroy(){await Promise.all(this.workers.map((async e=>{await this.destroyWorker(e)})))}setupHook(){}beforePromiseWorkerResponseHook(e){this.increaseWorkerRunningTasks(e)}afterPromiseWorkerResponseHook(e,r){this.decreaseWorkerRunningTasks(r.worker),this.stepWorkerRunTasks(r.worker,1),this.updateWorkerTasksRunTime(r.worker,e.taskRunTime)}removeWorker(e){this.workers.splice(this.getWorkerIndex(e),1),this.removeWorkerTasksUsage(e)}chooseWorker(){return this.workerChoiceStrategyContext.execute()}createAndSetupWorker(){const e=this.createWorker();return e.on("message",this.opts.messageHandler??i),e.on("error",this.opts.errorHandler??i),e.on("online",this.opts.onlineHandler??i),e.on("exit",this.opts.exitHandler??i),e.once("exit",(()=>{this.removeWorker(e)})),this.workers.push(e),this.initWorkerTasksUsage(e),this.afterWorkerSetup(e),e}workerListener(){return e=>{if(void 0!==e.id){const r=this.promiseMap.get(e.id);void 0!==r&&(null!=e.error?r.reject(e.error):r.resolve(e.data),this.afterPromiseWorkerResponseHook(e,r),this.promiseMap.delete(e.id))}}}async internalExecute(e,r){return this.beforePromiseWorkerResponseHook(e),await new Promise(((t,s)=>{this.promiseMap.set(r,{resolve:t,reject:s,worker:e})}))}checkAndEmitBusy(){!0===this.opts.enableEvents&&this.busy&&this.emitter?.emit("busy")}increaseWorkerRunningTasks(e){this.stepWorkerRunningTasks(e,1)}decreaseWorkerRunningTasks(e){this.stepWorkerRunningTasks(e,-1)}stepWorkerRunningTasks(e,r){if(this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.running=t.running+r,this.workersTasksUsage.set(e,t)}}stepWorkerRunTasks(e,r){if(this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.run=t.run+r,this.workersTasksUsage.set(e,t)}}updateWorkerTasksRunTime(e,r){if(this.workerChoiceStrategyContext.getWorkerChoiceStrategy().requiredStatistics.runTime&&this.checkWorkerTasksUsage(e)){const t=this.workersTasksUsage.get(e);t.runTime+=r??0,0!==t.run&&(t.avgRunTime=t.runTime/t.run),this.workersTasksUsage.set(e,t)}}checkWorkerTasksUsage(e){const r=this.workersTasksUsage.has(e);if(!r)throw new Error("Worker could not be found in workers tasks usage map");return r}initWorkerTasksUsage(e){this.workersTasksUsage.set(e,{run:0,running:0,runTime:0,avgRunTime:0})}removeWorkerTasksUsage(e){this.workersTasksUsage.delete(e)}resetWorkerTasksUsage(e){this.removeWorkerTasksUsage(e),this.initWorkerTasksUsage(e)}}class y extends d{opts;constructor(e,r,t=n){super(e,r,t),this.opts=t}setupHook(){e.setupPrimary({...this.opts.settings,exec:this.filePath})}isMain(){return e.isPrimary}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())}get type(){return a.FIXED}get busy(){return this.internalGetBusyStatus()}}class f extends d{constructor(e,r,t={}){super(e,r,t)}isMain(){return s.isMainThread}async destroyWorker(e){this.sendToWorker(e,{kill:1}),await e.terminate()}sendToWorker(e,r){e.postMessage(r)}registerWorkerMessageListener(e,r){e.port2?.on("message",r)}createWorker(){return new s.Worker(this.filePath,{env:s.SHARE_ENV})}afterWorkerSetup(e){const{port1:r,port2:t}=new s.MessageChannel;e.postMessage({parent:r},[r]),e.port1=r,e.port2=t,this.registerWorkerMessageListener(e,super.workerListener())}get type(){return a.FIXED}get busy(){return this.internalGetBusyStatus()}}const R=6e4,x=h.SOFT;class S extends o.AsyncResource{mainWorker;lastTaskTimestamp;aliveInterval;opts;constructor(e,r,t,s,o={killBehavior:x,maxInactiveTime:R}){super(e),this.mainWorker=s,this.opts=o,this.checkFunctionInput(t),this.checkWorkerOptions(this.opts),this.lastTaskTimestamp=Date.now(),r||(this.aliveInterval=setInterval(this.checkAlive.bind(this),(this.opts.maxInactiveTime??R)/2),this.checkAlive.bind(this)()),this.mainWorker?.on("message",(e=>{this.messageListener(e,t)}))}messageListener(e,r){void 0!==e.data&&void 0!==e.id?!0===this.opts.async?this.runInAsyncScope(this.runAsync.bind(this),this,r,e):this.runInAsyncScope(this.run.bind(this),this,r,e):void 0!==e.parent?this.mainWorker=e.parent:void 0!==e.kill&&(null!=this.aliveInterval&&clearInterval(this.aliveInterval),this.emitDestroy())}checkWorkerOptions(e){this.opts.killBehavior=e.killBehavior??x,this.opts.maxInactiveTime=e.maxInactiveTime??R,this.opts.async=e.async??!1}checkFunctionInput(e){if(null==e)throw new Error("fn parameter is mandatory");if("function"!=typeof e)throw new TypeError("fn parameter is not a function")}getMainWorker(){if(null==this.mainWorker)throw new Error("Main worker was not set");return this.mainWorker}checkAlive(){Date.now()-this.lastTaskTimestamp>(this.opts.maxInactiveTime??R)&&this.sendToMainWorker({kill:this.opts.killBehavior})}handleError(e){return e}run(e,r){try{const t=Date.now(),s=e(r.data),o=Date.now()-t;this.sendToMainWorker({data:s,id:r.id,taskRunTime:o})}catch(e){const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id})}finally{this.lastTaskTimestamp=Date.now()}}runAsync(e,r){const t=Date.now();e(r.data).then((e=>{const s=Date.now()-t;return this.sendToMainWorker({data:e,id:r.id,taskRunTime:s}),null})).catch((e=>{const t=this.handleError(e);this.sendToMainWorker({error:t,id:r.id})})).finally((()=>{this.lastTaskTimestamp=Date.now()})).catch(i)}}exports.ClusterWorker=class extends S{constructor(r,t=n){super("worker-cluster-pool:poolifier",e.isPrimary,r,e.worker,t)}sendToMainWorker(e){this.getMainWorker().send(e)}handleError(e){return e instanceof Error?e.message:e}},exports.DynamicClusterPool=class extends y{max;constructor(e,r,t,s=n){super(e,t,s),this.max=r}get type(){return a.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.DynamicThreadPool=class extends f{max;constructor(e,r,t,s={}){super(e,t,s),this.max=r}get type(){return a.DYNAMIC}get busy(){return this.workers.length===this.max}},exports.FixedClusterPool=y,exports.FixedThreadPool=f,exports.KillBehaviors=h,exports.ThreadWorker=class extends S{constructor(e,r=n){super("worker-thread-pool:poolifier",s.isMainThread,e,s.parentPort,r)}sendToMainWorker(e){this.getMainWorker().postMessage(e)}},exports.WorkerChoiceStrategies=c;

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

@@ -0,0 +1,219 @@
+import type { MessageValue, PromiseWorkerResponseWrapper } from '../utility-types';
+import type { PoolOptions } from './pool';
+import { PoolEmitter } from './pool';
+import type { IPoolInternal, TasksUsage } from './pool-internal';
+import { PoolType } from './pool-internal';
+import type { IPoolWorker } from './pool-worker';
+import { type WorkerChoiceStrategy } from './selection-strategies/selection-strategies-types';
+import { WorkerChoiceStrategyContext } from './selection-strategies/worker-choice-strategy-context';
+/**
+ * Base class that implements some shared logic for all poolifier pools.
+ *
+ * @typeParam Worker - Type of worker which manages this pool.
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export declare abstract class AbstractPool<Worker extends IPoolWorker, 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 workersTasksUsage: Map<Worker, TasksUsage>;
+    /** {@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;
+    private checkPoolOptions;
+    /** {@inheritDoc} */
+    abstract get type(): PoolType;
+    /** {@inheritDoc} */
+    get numberOfRunningTasks(): number;
+    /** {@inheritDoc} */
+    getWorkerIndex(worker: Worker): number;
+    /** {@inheritDoc} */
+    getWorkerRunningTasks(worker: Worker): number | undefined;
+    /** {@inheritDoc} */
+    getWorkerAverageTasksRunTime(worker: Worker): number | undefined;
+    /** {@inheritDoc} */
+    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
+    /** {@inheritDoc} */
+    abstract get busy(): boolean;
+    protected internalGetBusyStatus(): boolean;
+    /** {@inheritDoc} */
+    findFreeWorker(): Worker | false;
+    /** {@inheritDoc} */
+    execute(data: Data): Promise<Response>;
+    /** {@inheritDoc} */
+    destroy(): Promise<void>;
+    /**
+     * Shutdowns 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;
+    /**
+     * Hook executed before the worker task promise resolution.
+     * Can be overridden.
+     *
+     * @param worker - The worker.
+     */
+    protected beforePromiseWorkerResponseHook(worker: Worker): void;
+    /**
+     * Hook executed after the worker task promise resolution.
+     * Can be overridden.
+     *
+     * @param message - The received message.
+     * @param promise - The Promise response.
+     */
+    protected afterPromiseWorkerResponseHook(message: MessageValue<Response>, promise: PromiseWorkerResponseWrapper<Worker, Response>): void;
+    /**
+     * Removes the given worker from the pool.
+     *
+     * @param worker - The worker that will be removed.
+     */
+    protected removeWorker(worker: Worker): void;
+    /**
+     * Chooses a worker for the next task.
+     *
+     * The default implementation uses a round robin algorithm to distribute the load.
+     *
+     * @returns Worker.
+     */
+    protected chooseWorker(): Worker;
+    /**
+     * Sends 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;
+    /**
+     * Registers a listener callback on a given worker.
+     *
+     * @param worker - The worker which should register a listener.
+     * @param listener - The message listener callback.
+     */
+    protected abstract registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
+    /**
+     * 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 received from a worker.
+     */
+    protected workerListener(): (message: MessageValue<Response>) => void;
+    private internalExecute;
+    private checkAndEmitBusy;
+    /**
+     * Increases the number of tasks that the given worker has applied.
+     *
+     * @param worker - Worker which running tasks is increased.
+     */
+    private increaseWorkerRunningTasks;
+    /**
+     * Decreases the number of tasks that the given worker has applied.
+     *
+     * @param worker - Worker which running tasks is decreased.
+     */
+    private decreaseWorkerRunningTasks;
+    /**
+     * Steps the number of tasks that the given worker has applied.
+     *
+     * @param worker - Worker which running tasks are stepped.
+     * @param step - Number of running tasks step.
+     */
+    private stepWorkerRunningTasks;
+    /**
+     * Steps the number of tasks that the given worker has run.
+     *
+     * @param worker - Worker which has run tasks.
+     * @param step - Number of run tasks step.
+     */
+    private stepWorkerRunTasks;
+    /**
+     * Updates tasks runtime for the given worker.
+     *
+     * @param worker - Worker which run the task.
+     * @param taskRunTime - Worker task runtime.
+     */
+    private updateWorkerTasksRunTime;
+    /**
+     * Checks if the given worker is registered in the workers tasks usage map.
+     *
+     * @param worker - Worker to check.
+     * @returns `true` if the worker is registered in the workers tasks usage map. `false` otherwise.
+     */
+    private checkWorkerTasksUsage;
+    /**
+     * Initializes tasks usage statistics.
+     *
+     * @param worker - The worker.
+     */
+    private initWorkerTasksUsage;
+    /**
+     * Removes worker tasks usage statistics.
+     *
+     * @param worker - The worker.
+     */
+    private removeWorkerTasksUsage;
+    /**
+     * Resets worker tasks usage statistics.
+     *
+     * @param worker - The worker.
+     */
+    private resetWorkerTasksUsage;
+}

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

@@ -0,0 +1,30 @@
+import { PoolType } from '../pool-internal';
+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`.
+ *
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam 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> {
+    protected 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.
+     */
+    constructor(min: number, max: number, filePath: string, opts?: ClusterPoolOptions);
+    /** {@inheritDoc} */
+    get type(): PoolType;
+    /** {@inheritDoc} */
+    get busy(): boolean;
+}

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

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import type { ClusterSettings, Worker } from 'cluster';
+import type { MessageValue } from '../../utility-types';
+import { AbstractPool } from '../abstract-pool';
+import type { PoolOptions } from '../pool';
+import { PoolType } from '../pool-internal';
+/**
+ * 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;
+    /**
+     * Cluster settings.
+     *
+     * @see https://nodejs.org/api/cluster.html#cluster_cluster_settings
+     */
+    settings?: ClusterSettings;
+}
+/**
+ * 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.
+ *
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam 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.
+     */
+    constructor(numberOfWorkers: number, filePath: string, opts?: ClusterPoolOptions);
+    /** {@inheritDoc} */
+    protected setupHook(): void;
+    /** {@inheritDoc} */
+    protected isMain(): boolean;
+    /** {@inheritDoc} */
+    destroyWorker(worker: Worker): void;
+    /** {@inheritDoc} */
+    protected sendToWorker(worker: Worker, message: MessageValue<Data>): void;
+    /** {@inheritDoc} */
+    registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
+    /** {@inheritDoc} */
+    protected createWorker(): Worker;
+    /** {@inheritDoc} */
+    protected afterWorkerSetup(worker: Worker): void;
+    /** {@inheritDoc} */
+    get type(): PoolType;
+    /** {@inheritDoc} */
+    get busy(): boolean;
+}

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

@@ -0,0 +1,85 @@
+import type { IPool } from './pool';
+import type { IPoolWorker } from './pool-worker';
+/**
+ * Internal pool types.
+ */
+export declare enum PoolType {
+    FIXED = "fixed",
+    DYNAMIC = "dynamic"
+}
+/**
+ * Internal tasks usage statistics.
+ */
+export interface TasksUsage {
+    run: number;
+    running: number;
+    runTime: number;
+    avgRunTime: number;
+}
+/**
+ * Internal contract definition for a poolifier pool.
+ *
+ * @typeParam Worker - Type of worker which manages this pool.
+ * @typeParam Data - Type of data sent to the worker.
+ * @typeParam Response - Type of response of execution.
+ */
+export interface IPoolInternal<Worker extends IPoolWorker, Data = unknown, Response = unknown> extends IPool<Data, Response> {
+    /**
+     * List of currently available workers.
+     */
+    readonly workers: Worker[];
+    /**
+     * The workers tasks usage map.
+     *
+     *  `key`: The `Worker`
+     *  `value`: Worker tasks usage statistics.
+     */
+    readonly workersTasksUsage: Map<Worker, TasksUsage>;
+    /**
+     * Pool type.
+     *
+     * If it is `'dynamic'`, it provides the `max` property.
+     */
+    readonly type: PoolType;
+    /**
+     * Whether the pool is busy or not.
+     *
+     * The pool busyness boolean status.
+     */
+    readonly busy: boolean;
+    /**
+     * Number of tasks currently concurrently running.
+     */
+    readonly numberOfRunningTasks: number;
+    /**
+     * Finds a free worker based on the number of tasks the worker has applied.
+     *
+     * If a worker is found with `0` running tasks, it is detected as free and returned.
+     *
+     * If no free worker is found, `false` is returned.
+     *
+     * @returns A free worker if there is one, otherwise `false`.
+     */
+    findFreeWorker: () => Worker | false;
+    /**
+     * Gets worker index.
+     *
+     * @param worker - The worker.
+     * @returns The worker index.
+     */
+    getWorkerIndex: (worker: Worker) => number;
+    /**
+     * Gets worker running tasks.
+     *
+     * @param worker - The worker.
+     * @returns The number of tasks currently running on the worker.
+     */
+    getWorkerRunningTasks: (worker: Worker) => number | undefined;
+    /**
+     * Gets worker average tasks runtime.
+     *
+     * @param worker - The worker.
+     * @returns The average tasks runtime on the worker.
+     */
+    getWorkerAverageTasksRunTime: (worker: Worker) => number | undefined;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Callback invoked if the worker has received a message.
+ */
+export type MessageHandler<Worker> = (this: Worker, m: unknown) => void;
+/**
+ * Callback invoked if the worker raised an error.
+ */
+export type ErrorHandler<Worker> = (this: Worker, e: Error) => void;
+/**
+ * Callback invoked when the worker has started successfully.
+ */
+export type OnlineHandler<Worker> = (this: Worker) => void;
+/**
+ * Callback invoked when the worker exits successfully.
+ */
+export type ExitHandler<Worker> = (this: Worker, code: number) => void;
+/**
+ * Interface that describes the minimum required implementation of listener events for a pool worker.
+ */
+export interface IPoolWorker {
+    /**
+     * Register an event listener.
+     *
+     * @param event - The event.
+     * @param handler - The event listener.
+     */
+    on: ((event: 'message', handler: MessageHandler<this>) => void) & ((event: 'error', handler: ErrorHandler<this>) => void) & ((event: 'online', handler: OnlineHandler<this>) => void) & ((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;
+}

package/lib/pools/pool.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import type { ErrorHandler, ExitHandler, MessageHandler, OnlineHandler } from './pool-worker';
+import type { WorkerChoiceStrategy } from './selection-strategies/selection-strategies-types';
+/**
+ * Pool events emitter.
+ */
+export declare class PoolEmitter extends EventEmitter {
+}
+/**
+ * Options for a poolifier pool.
+ */
+export interface PoolOptions<Worker> {
+    /**
+     * A function that will listen for message event on each worker.
+     */
+    messageHandler?: MessageHandler<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 worker choice strategy to use in this pool.
+     */
+    workerChoiceStrategy?: WorkerChoiceStrategy;
+    /**
+     * Pool events emission.
+     *
+     * @defaultValue true
+     */
+    enableEvents?: boolean;
+}
+/**
+ * Contract definition for a poolifier pool.
+ *
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export interface IPool<Data = unknown, Response = unknown> {
+    /**
+     * Emitter on which events can be listened to.
+     *
+     * Events that can currently be listened to:
+     *
+     * - `'busy'`
+     */
+    readonly emitter?: PoolEmitter;
+    /**
+     * Performs 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>;
+    /**
+     * Shutdowns every current worker in this pool.
+     */
+    destroy: () => Promise<void>;
+    /**
+     * Sets the worker choice strategy in this pool.
+     *
+     * @param workerChoiceStrategy - The worker choice strategy.
+     */
+    setWorkerChoiceStrategy: (workerChoiceStrategy: WorkerChoiceStrategy) => void;
+}

package/lib/pools/selection-strategies/abstract-worker-choice-strategy.d.ts

@@ -0,0 +1,27 @@
+import type { IPoolInternal } from '../pool-internal';
+import type { IPoolWorker } from '../pool-worker';
+import type { IWorkerChoiceStrategy, RequiredStatistics } from './selection-strategies-types';
+/**
+ * Abstract worker choice strategy class.
+ *
+ * @typeParam Worker - Type of worker which manages the strategy.
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export declare abstract class AbstractWorkerChoiceStrategy<Worker extends IPoolWorker, Data, Response> implements IWorkerChoiceStrategy<Worker> {
+    protected readonly pool: IPoolInternal<Worker, Data, Response>;
+    /** {@inheritDoc} */
+    readonly isDynamicPool: boolean;
+    /** {@inheritDoc} */
+    requiredStatistics: RequiredStatistics;
+    /**
+     * Constructs a worker choice strategy attached to the pool.
+     *
+     * @param pool - The pool instance.
+     */
+    constructor(pool: IPoolInternal<Worker, Data, Response>);
+    /** {@inheritDoc} */
+    abstract reset(): boolean;
+    /** {@inheritDoc} */
+    abstract choose(): Worker;
+}

package/lib/pools/selection-strategies/dynamic-pool-worker-choice-strategy.d.ts

@@ -0,0 +1,27 @@
+import type { IPoolInternal } from '../pool-internal';
+import type { IPoolWorker } from '../pool-worker';
+import { AbstractWorkerChoiceStrategy } from './abstract-worker-choice-strategy';
+import type { WorkerChoiceStrategy } from './selection-strategies-types';
+/**
+ * Selects the next worker for dynamic pool.
+ *
+ * @typeParam Worker - Type of worker which manages the strategy.
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export declare class DynamicPoolWorkerChoiceStrategy<Worker extends IPoolWorker, Data, Response> extends AbstractWorkerChoiceStrategy<Worker, Data, Response> {
+    private readonly createDynamicallyWorkerCallback;
+    private readonly workerChoiceStrategy;
+    /**
+     * Constructs a worker choice strategy for dynamic pool.
+     *
+     * @param pool - The pool instance.
+     * @param createDynamicallyWorkerCallback - The worker creation callback for dynamic pool.
+     * @param workerChoiceStrategy - The worker choice strategy when the pull is busy.
+     */
+    constructor(pool: IPoolInternal<Worker, Data, Response>, createDynamicallyWorkerCallback: () => Worker, workerChoiceStrategy?: WorkerChoiceStrategy);
+    /** {@inheritDoc} */
+    reset(): boolean;
+    /** {@inheritDoc} */
+    choose(): Worker;
+}

package/lib/pools/selection-strategies/fair-share-worker-choice-strategy.d.ts

@@ -0,0 +1,29 @@
+import type { IPoolWorker } from '../pool-worker';
+import { AbstractWorkerChoiceStrategy } from './abstract-worker-choice-strategy';
+import type { RequiredStatistics } from './selection-strategies-types';
+/**
+ * Selects the next worker with a fair share scheduling algorithm.
+ * Loosely modeled after the fair queueing algorithm: https://en.wikipedia.org/wiki/Fair_queuing.
+ *
+ * @typeParam Worker - Type of worker which manages the strategy.
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export declare class FairShareWorkerChoiceStrategy<Worker extends IPoolWorker, Data, Response> extends AbstractWorkerChoiceStrategy<Worker, Data, Response> {
+    /** {@inheritDoc} */
+    readonly requiredStatistics: RequiredStatistics;
+    /**
+     *  Worker last virtual task execution timestamp.
+     */
+    private readonly workerLastVirtualTaskTimestamp;
+    /** {@inheritDoc} */
+    reset(): boolean;
+    /** {@inheritDoc} */
+    choose(): Worker;
+    /**
+     * Computes worker last virtual task timestamp.
+     *
+     * @param worker - The worker.
+     */
+    private computeWorkerLastVirtualTaskTimestamp;
+}

package/lib/pools/selection-strategies/less-recently-used-worker-choice-strategy.d.ts

@@ -0,0 +1,15 @@
+import type { IPoolWorker } from '../pool-worker';
+import { AbstractWorkerChoiceStrategy } from './abstract-worker-choice-strategy';
+/**
+ * Selects the less recently used worker.
+ *
+ * @typeParam Worker - Type of worker which manages the strategy.
+ * @typeParam Data - Type of data sent to the worker. This can only be serializable data.
+ * @typeParam Response - Type of response of execution. This can only be serializable data.
+ */
+export declare class LessRecentlyUsedWorkerChoiceStrategy<Worker extends IPoolWorker, Data, Response> extends AbstractWorkerChoiceStrategy<Worker, Data, Response> {
+    /** {@inheritDoc} */
+    reset(): boolean;
+    /** {@inheritDoc} */
+    choose(): Worker;
+}