@eggjs/mock 6.0.7 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Pool.js

@@ -0,0 +1,366 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_environment } from "./environment.js";
+import { require_Promise } from "./Promise.js";
+import { require_WorkerHandler } from "./WorkerHandler.js";
+import { require_debug_port_allocator } from "./debug-port-allocator.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Pool.js
+var require_Pool = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Pool.js": ((exports, module) => {
+	var { Promise: Promise$1 } = require_Promise();
+	var WorkerHandler = require_WorkerHandler();
+	var environment = require_environment();
+	var DEBUG_PORT_ALLOCATOR = new (require_debug_port_allocator())();
+	/**
+	* A pool to manage workers, which can be created using the function workerpool.pool.
+	*
+	* @param {String} [script]   Optional worker script
+	* @param {import('./types.js').WorkerPoolOptions} [options]  See docs
+	* @constructor
+	*/
+	function Pool(script, options) {
+		if (typeof script === "string")
+ /** @readonly */
+		this.script = script || null;
+		else {
+			this.script = null;
+			options = script;
+		}
+		/** @private */
+		this.workers = [];
+		/** @private */
+		this.tasks = [];
+		options = options || {};
+		/** @readonly */
+		this.forkArgs = Object.freeze(options.forkArgs || []);
+		/** @readonly */
+		this.forkOpts = Object.freeze(options.forkOpts || {});
+		/** @readonly */
+		this.workerOpts = Object.freeze(options.workerOpts || {});
+		/** @readonly */
+		this.workerThreadOpts = Object.freeze(options.workerThreadOpts || {});
+		/** @private */
+		this.debugPortStart = options.debugPortStart || 43210;
+		/** @readonly @deprecated */
+		this.nodeWorker = options.nodeWorker;
+		/** @readonly
+		* @type {'auto' | 'web' | 'process' | 'thread'}
+		*/
+		this.workerType = options.workerType || options.nodeWorker || "auto";
+		/** @readonly */
+		this.maxQueueSize = options.maxQueueSize || Infinity;
+		/** @readonly */
+		this.workerTerminateTimeout = options.workerTerminateTimeout || 1e3;
+		/** @readonly */
+		this.onCreateWorker = options.onCreateWorker || (() => null);
+		/** @readonly */
+		this.onTerminateWorker = options.onTerminateWorker || (() => null);
+		/** @readonly */
+		this.emitStdStreams = options.emitStdStreams || false;
+		if (options && "maxWorkers" in options) {
+			validateMaxWorkers(options.maxWorkers);
+			/** @readonly */
+			this.maxWorkers = options.maxWorkers;
+		} else this.maxWorkers = Math.max((environment.cpus || 4) - 1, 1);
+		if (options && "minWorkers" in options) {
+			if (options.minWorkers === "max")
+ /** @readonly */
+			this.minWorkers = this.maxWorkers;
+			else {
+				validateMinWorkers(options.minWorkers);
+				this.minWorkers = options.minWorkers;
+				this.maxWorkers = Math.max(this.minWorkers, this.maxWorkers);
+			}
+			this._ensureMinWorkers();
+		}
+		/** @private */
+		this._boundNext = this._next.bind(this);
+		if (this.workerType === "thread") WorkerHandler.ensureWorkerThreads();
+	}
+	/**
+	* Execute a function on a worker.
+	*
+	* Example usage:
+	*
+	*   var pool = new Pool()
+	*
+	*   // call a function available on the worker
+	*   pool.exec('fibonacci', [6])
+	*
+	*   // offload a function
+	*   function add(a, b) {
+	*     return a + b
+	*   };
+	*   pool.exec(add, [2, 4])
+	*       .then(function (result) {
+	*         console.log(result); // outputs 6
+	*       })
+	*       .catch(function(error) {
+	*         console.log(error);
+	*       });
+	* @template { (...args: any[]) => any } T
+	* @param {String | T} method  Function name or function.
+	*                                    If `method` is a string, the corresponding
+	*                                    method on the worker will be executed
+	*                                    If `method` is a Function, the function
+	*                                    will be stringified and executed via the
+	*                                    workers built-in function `run(fn, args)`.
+	* @param {Parameters<T> | null} [params]  Function arguments applied when calling the function
+	* @param {import('./types.js').ExecOptions} [options]  Options
+	* @return {Promise<ReturnType<T>>}
+	*/
+	Pool.prototype.exec = function(method, params, options) {
+		if (params && !Array.isArray(params)) throw new TypeError("Array expected as argument \"params\"");
+		if (typeof method === "string") {
+			var resolver = Promise$1.defer();
+			if (this.tasks.length >= this.maxQueueSize) throw new Error("Max queue size of " + this.maxQueueSize + " reached");
+			var tasks = this.tasks;
+			var task = {
+				method,
+				params,
+				resolver,
+				timeout: null,
+				options
+			};
+			tasks.push(task);
+			var originalTimeout = resolver.promise.timeout;
+			resolver.promise.timeout = function timeout(delay) {
+				if (tasks.indexOf(task) !== -1) {
+					task.timeout = delay;
+					return resolver.promise;
+				} else return originalTimeout.call(resolver.promise, delay);
+			};
+			this._next();
+			return resolver.promise;
+		} else if (typeof method === "function") return this.exec("run", [String(method), params], options);
+		else throw new TypeError("Function or string expected as argument \"method\"");
+	};
+	/**
+	* Create a proxy for current worker. Returns an object containing all
+	* methods available on the worker. All methods return promises resolving the methods result.
+	* @template { { [k: string]: (...args: any[]) => any } } T
+	* @return {Promise<import('./types.js').Proxy<T>, Error>} Returns a promise which resolves with a proxy object
+	*/
+	Pool.prototype.proxy = function() {
+		if (arguments.length > 0) throw new Error("No arguments expected");
+		var pool = this;
+		return this.exec("methods").then(function(methods) {
+			var proxy = {};
+			methods.forEach(function(method) {
+				proxy[method] = function() {
+					return pool.exec(method, Array.prototype.slice.call(arguments));
+				};
+			});
+			return proxy;
+		});
+	};
+	/**
+	* Creates new array with the results of calling a provided callback function
+	* on every element in this array.
+	* @param {Array} array
+	* @param {function} callback  Function taking two arguments:
+	*                             `callback(currentValue, index)`
+	* @return {Promise.<Array>} Returns a promise which resolves  with an Array
+	*                           containing the results of the callback function
+	*                           executed for each of the array elements.
+	*/
+	/**
+	* Grab the first task from the queue, find a free worker, and assign the
+	* worker to the task.
+	* @private
+	*/
+	Pool.prototype._next = function() {
+		if (this.tasks.length > 0) {
+			var worker = this._getWorker();
+			if (worker) {
+				var me = this;
+				var task = this.tasks.shift();
+				if (task.resolver.promise.pending) {
+					var promise = worker.exec(task.method, task.params, task.resolver, task.options).then(me._boundNext).catch(function() {
+						if (worker.terminated) return me._removeWorker(worker);
+					}).then(function() {
+						me._next();
+					});
+					if (typeof task.timeout === "number") promise.timeout(task.timeout);
+				} else me._next();
+			}
+		}
+	};
+	/**
+	* Get an available worker. If no worker is available and the maximum number
+	* of workers isn't yet reached, a new worker will be created and returned.
+	* If no worker is available and the maximum number of workers is reached,
+	* null will be returned.
+	*
+	* @return {WorkerHandler | null} worker
+	* @private
+	*/
+	Pool.prototype._getWorker = function() {
+		var workers = this.workers;
+		for (var i = 0; i < workers.length; i++) {
+			var worker = workers[i];
+			if (worker.busy() === false) return worker;
+		}
+		if (workers.length < this.maxWorkers) {
+			worker = this._createWorkerHandler();
+			workers.push(worker);
+			return worker;
+		}
+		return null;
+	};
+	/**
+	* Remove a worker from the pool.
+	* Attempts to terminate worker if not already terminated, and ensures the minimum
+	* pool size is met.
+	* @param {WorkerHandler} worker
+	* @return {Promise<WorkerHandler>}
+	* @private
+	*/
+	Pool.prototype._removeWorker = function(worker) {
+		var me = this;
+		DEBUG_PORT_ALLOCATOR.releasePort(worker.debugPort);
+		this._removeWorkerFromList(worker);
+		this._ensureMinWorkers();
+		return new Promise$1(function(resolve, reject) {
+			worker.terminate(false, function(err) {
+				me.onTerminateWorker({
+					forkArgs: worker.forkArgs,
+					forkOpts: worker.forkOpts,
+					workerThreadOpts: worker.workerThreadOpts,
+					script: worker.script
+				});
+				if (err) reject(err);
+				else resolve(worker);
+			});
+		});
+	};
+	/**
+	* Remove a worker from the pool list.
+	* @param {WorkerHandler} worker
+	* @private
+	*/
+	Pool.prototype._removeWorkerFromList = function(worker) {
+		var index = this.workers.indexOf(worker);
+		if (index !== -1) this.workers.splice(index, 1);
+	};
+	/**
+	* Close all active workers. Tasks currently being executed will be finished first.
+	* @param {boolean} [force=false]   If false (default), the workers are terminated
+	*                                  after finishing all tasks currently in
+	*                                  progress. If true, the workers will be
+	*                                  terminated immediately.
+	* @param {number} [timeout]        If provided and non-zero, worker termination promise will be rejected
+	*                                  after timeout if worker process has not been terminated.
+	* @return {Promise.<void, Error>}
+	*/
+	Pool.prototype.terminate = function(force, timeout) {
+		var me = this;
+		this.tasks.forEach(function(task) {
+			task.resolver.reject(/* @__PURE__ */ new Error("Pool terminated"));
+		});
+		this.tasks.length = 0;
+		var f = function(worker) {
+			DEBUG_PORT_ALLOCATOR.releasePort(worker.debugPort);
+			this._removeWorkerFromList(worker);
+		};
+		var removeWorker = f.bind(this);
+		var promises = [];
+		this.workers.slice().forEach(function(worker) {
+			var termPromise = worker.terminateAndNotify(force, timeout).then(removeWorker).always(function() {
+				me.onTerminateWorker({
+					forkArgs: worker.forkArgs,
+					forkOpts: worker.forkOpts,
+					workerThreadOpts: worker.workerThreadOpts,
+					script: worker.script
+				});
+			});
+			promises.push(termPromise);
+		});
+		return Promise$1.all(promises);
+	};
+	/**
+	* Retrieve statistics on tasks and workers.
+	* @return {{totalWorkers: number, busyWorkers: number, idleWorkers: number, pendingTasks: number, activeTasks: number}} Returns an object with statistics
+	*/
+	Pool.prototype.stats = function() {
+		var totalWorkers = this.workers.length;
+		var busyWorkers = this.workers.filter(function(worker) {
+			return worker.busy();
+		}).length;
+		return {
+			totalWorkers,
+			busyWorkers,
+			idleWorkers: totalWorkers - busyWorkers,
+			pendingTasks: this.tasks.length,
+			activeTasks: busyWorkers
+		};
+	};
+	/**
+	* Ensures that a minimum of minWorkers is up and running
+	* @private
+	*/
+	Pool.prototype._ensureMinWorkers = function() {
+		if (this.minWorkers) for (var i = this.workers.length; i < this.minWorkers; i++) this.workers.push(this._createWorkerHandler());
+	};
+	/**
+	* Helper function to create a new WorkerHandler and pass all options.
+	* @return {WorkerHandler}
+	* @private
+	*/
+	Pool.prototype._createWorkerHandler = function() {
+		const overriddenParams = this.onCreateWorker({
+			forkArgs: this.forkArgs,
+			forkOpts: this.forkOpts,
+			workerOpts: this.workerOpts,
+			workerThreadOpts: this.workerThreadOpts,
+			script: this.script
+		}) || {};
+		return new WorkerHandler(overriddenParams.script || this.script, {
+			forkArgs: overriddenParams.forkArgs || this.forkArgs,
+			forkOpts: overriddenParams.forkOpts || this.forkOpts,
+			workerOpts: overriddenParams.workerOpts || this.workerOpts,
+			workerThreadOpts: overriddenParams.workerThreadOpts || this.workerThreadOpts,
+			debugPort: DEBUG_PORT_ALLOCATOR.nextAvailableStartingAt(this.debugPortStart),
+			workerType: this.workerType,
+			workerTerminateTimeout: this.workerTerminateTimeout,
+			emitStdStreams: this.emitStdStreams
+		});
+	};
+	/**
+	* Ensure that the maxWorkers option is an integer >= 1
+	* @param {*} maxWorkers
+	* @returns {boolean} returns true maxWorkers has a valid value
+	*/
+	function validateMaxWorkers(maxWorkers) {
+		if (!isNumber(maxWorkers) || !isInteger(maxWorkers) || maxWorkers < 1) throw new TypeError("Option maxWorkers must be an integer number >= 1");
+	}
+	/**
+	* Ensure that the minWorkers option is an integer >= 0
+	* @param {*} minWorkers
+	* @returns {boolean} returns true when minWorkers has a valid value
+	*/
+	function validateMinWorkers(minWorkers) {
+		if (!isNumber(minWorkers) || !isInteger(minWorkers) || minWorkers < 0) throw new TypeError("Option minWorkers must be an integer number >= 0");
+	}
+	/**
+	* Test whether a variable is a number
+	* @param {*} value
+	* @returns {boolean} returns true when value is a number
+	*/
+	function isNumber(value) {
+		return typeof value === "number";
+	}
+	/**
+	* Test whether a number is an integer
+	* @param {number} value
+	* @returns {boolean} Returns true if value is an integer
+	*/
+	function isInteger(value) {
+		return Math.round(value) == value;
+	}
+	module.exports = Pool;
+}) });
+
+//#endregion
+export default require_Pool();
+
+export { require_Pool };

package/dist/node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Promise.js

@@ -0,0 +1,248 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Promise.js
+var require_Promise = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/workerpool@9.3.4/node_modules/workerpool/src/Promise.js": ((exports) => {
+	/**
+	* Promise
+	*
+	* Inspired by https://gist.github.com/RubaXa/8501359 from RubaXa <trash@rubaxa.org>
+	* @template T
+	* @template [E=Error]
+	* @param {Function} handler   Called as handler(resolve: Function, reject: Function)
+	* @param {Promise} [parent]   Parent promise for propagation of cancel and timeout
+	*/
+	function Promise$1(handler, parent) {
+		var me = this;
+		if (!(this instanceof Promise$1)) throw new SyntaxError("Constructor must be called with the new operator");
+		if (typeof handler !== "function") throw new SyntaxError("Function parameter handler(resolve, reject) missing");
+		var _onSuccess = [];
+		var _onFail = [];
+		/**
+		* @readonly
+		*/
+		this.resolved = false;
+		/**
+		* @readonly
+		*/
+		this.rejected = false;
+		/**
+		* @readonly
+		*/
+		this.pending = true;
+		/**
+		* @readonly
+		*/
+		this[Symbol.toStringTag] = "Promise";
+		/**
+		* Process onSuccess and onFail callbacks: add them to the queue.
+		* Once the promise is resolved, the function _promise is replace.
+		* @param {Function} onSuccess
+		* @param {Function} onFail
+		* @private
+		*/
+		var _process = function(onSuccess, onFail) {
+			_onSuccess.push(onSuccess);
+			_onFail.push(onFail);
+		};
+		/**
+		* Add an onSuccess callback and optionally an onFail callback to the Promise
+		* @template TT
+		* @template [TE=never]
+		* @param {(r: T) => TT | PromiseLike<TT>} onSuccess
+		* @param {(r: E) => TE | PromiseLike<TE>} [onFail]
+		* @returns {Promise<TT | TE, any>} promise
+		*/
+		this.then = function(onSuccess, onFail) {
+			return new Promise$1(function(resolve, reject) {
+				var s = onSuccess ? _then(onSuccess, resolve, reject) : resolve;
+				var f = onFail ? _then(onFail, resolve, reject) : reject;
+				_process(s, f);
+			}, me);
+		};
+		/**
+		* Resolve the promise
+		* @param {*} result
+		* @type {Function}
+		*/
+		var _resolve = function(result) {
+			me.resolved = true;
+			me.rejected = false;
+			me.pending = false;
+			_onSuccess.forEach(function(fn) {
+				fn(result);
+			});
+			_process = function(onSuccess, onFail) {
+				onSuccess(result);
+			};
+			_resolve = _reject = function() {};
+			return me;
+		};
+		/**
+		* Reject the promise
+		* @param {Error} error
+		* @type {Function}
+		*/
+		var _reject = function(error) {
+			me.resolved = false;
+			me.rejected = true;
+			me.pending = false;
+			_onFail.forEach(function(fn) {
+				fn(error);
+			});
+			_process = function(onSuccess, onFail) {
+				onFail(error);
+			};
+			_resolve = _reject = function() {};
+			return me;
+		};
+		/**
+		* Cancel the promise. This will reject the promise with a CancellationError
+		* @returns {this} self
+		*/
+		this.cancel = function() {
+			if (parent) parent.cancel();
+			else _reject(new CancellationError());
+			return me;
+		};
+		/**
+		* Set a timeout for the promise. If the promise is not resolved within
+		* the time, the promise will be cancelled and a TimeoutError is thrown.
+		* If the promise is resolved in time, the timeout is removed.
+		* @param {number} delay     Delay in milliseconds
+		* @returns {this} self
+		*/
+		this.timeout = function(delay) {
+			if (parent) parent.timeout(delay);
+			else {
+				var timer = setTimeout(function() {
+					_reject(new TimeoutError("Promise timed out after " + delay + " ms"));
+				}, delay);
+				me.always(function() {
+					clearTimeout(timer);
+				});
+			}
+			return me;
+		};
+		handler(function(result) {
+			_resolve(result);
+		}, function(error) {
+			_reject(error);
+		});
+	}
+	/**
+	* Execute given callback, then call resolve/reject based on the returned result
+	* @param {Function} callback
+	* @param {Function} resolve
+	* @param {Function} reject
+	* @returns {Function}
+	* @private
+	*/
+	function _then(callback, resolve, reject) {
+		return function(result) {
+			try {
+				var res = callback(result);
+				if (res && typeof res.then === "function" && typeof res["catch"] === "function") res.then(resolve, reject);
+				else resolve(res);
+			} catch (error) {
+				reject(error);
+			}
+		};
+	}
+	/**
+	* Add an onFail callback to the Promise
+	* @template TT
+	* @param {(error: E) => TT | PromiseLike<TT>} onFail
+	* @returns {Promise<T | TT>} promise
+	*/
+	Promise$1.prototype["catch"] = function(onFail) {
+		return this.then(null, onFail);
+	};
+	/**
+	* Execute given callback when the promise either resolves or rejects.
+	* @template TT
+	* @param {() => Promise<TT>} fn
+	* @returns {Promise<TT>} promise
+	*/
+	Promise$1.prototype.always = function(fn) {
+		return this.then(fn, fn);
+	};
+	/**
+	* Execute given callback when the promise either resolves or rejects.
+	* Same semantics as Node's Promise.finally()
+	* @param {Function | null | undefined} [fn]
+	* @returns {Promise} promise
+	*/
+	Promise$1.prototype.finally = function(fn) {
+		const me = this;
+		const final = function() {
+			return new Promise$1((resolve) => resolve()).then(fn).then(() => me);
+		};
+		return this.then(final, final);
+	};
+	/**
+	* Create a promise which resolves when all provided promises are resolved,
+	* and fails when any of the promises resolves.
+	* @param {Promise[]} promises
+	* @returns {Promise<any[], any>} promise
+	*/
+	Promise$1.all = function(promises) {
+		return new Promise$1(function(resolve, reject) {
+			var remaining = promises.length, results = [];
+			if (remaining) promises.forEach(function(p, i) {
+				p.then(function(result) {
+					results[i] = result;
+					remaining--;
+					if (remaining == 0) resolve(results);
+				}, function(error) {
+					remaining = 0;
+					reject(error);
+				});
+			});
+			else resolve(results);
+		});
+	};
+	/**
+	* Create a promise resolver
+	* @returns {{promise: Promise, resolve: Function, reject: Function}} resolver
+	*/
+	Promise$1.defer = function() {
+		var resolver = {};
+		resolver.promise = new Promise$1(function(resolve, reject) {
+			resolver.resolve = resolve;
+			resolver.reject = reject;
+		});
+		return resolver;
+	};
+	/**
+	* Create a cancellation error
+	* @param {String} [message]
+	* @extends Error
+	*/
+	function CancellationError(message) {
+		this.message = message || "promise cancelled";
+		this.stack = (/* @__PURE__ */ new Error()).stack;
+	}
+	CancellationError.prototype = /* @__PURE__ */ new Error();
+	CancellationError.prototype.constructor = Error;
+	CancellationError.prototype.name = "CancellationError";
+	Promise$1.CancellationError = CancellationError;
+	/**
+	* Create a timeout error
+	* @param {String} [message]
+	* @extends Error
+	*/
+	function TimeoutError(message) {
+		this.message = message || "timeout exceeded";
+		this.stack = (/* @__PURE__ */ new Error()).stack;
+	}
+	TimeoutError.prototype = /* @__PURE__ */ new Error();
+	TimeoutError.prototype.constructor = Error;
+	TimeoutError.prototype.name = "TimeoutError";
+	Promise$1.TimeoutError = TimeoutError;
+	exports.Promise = Promise$1;
+}) });
+
+//#endregion
+export default require_Promise();
+
+export { require_Promise };