@eggjs/mock 6.1.0-beta.9 → 7.0.0-beta.13

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

@@ -1,366 +0,0 @@
-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

@@ -1,248 +0,0 @@
-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 };