@eggjs/mock 6.0.7 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/serializer.js

@@ -0,0 +1,314 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../utils.js";
+import { require_src } from "../../../../../debug@4.4.3_supports-color@8.1.1/node_modules/debug/src/index.js";
+import { require_errors } from "../errors.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/serializer.js
+var require_serializer = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/nodejs/serializer.js": ((exports) => {
+	/**
+	* @typedef {import('../types.d.ts').SerializedEvent} SerializedEvent
+	* @typedef {import('../types.d.ts').SerializedWorkerResult} SerializedWorkerResult
+	*/
+	const { type, breakCircularDeps } = require_utils();
+	const { createInvalidArgumentTypeError } = require_errors();
+	const debug = require_src()("mocha:serializer");
+	const SERIALIZABLE_RESULT_NAME = "SerializableWorkerResult";
+	const SERIALIZABLE_TYPES = new Set([
+		"object",
+		"array",
+		"function",
+		"error"
+	]);
+	/**
+	* The serializable result of a test file run from a worker.
+	* @private
+	*/
+	var SerializableWorkerResult = class SerializableWorkerResult {
+		/**
+		* Creates instance props; of note, the `__type` prop.
+		*
+		* Note that the failure count is _redundant_ and could be derived from the
+		* list of events; but since we're already doing the work, might as well use
+		* it.
+		* @param {SerializableEvent[]} [events=[]] - Events to eventually serialize
+		* @param {number} [failureCount=0] - Failure count
+		*/
+		constructor(events = [], failureCount = 0) {
+			/**
+			* The number of failures in this run
+			* @type {number}
+			*/
+			this.failureCount = failureCount;
+			/**
+			* All relevant events emitted from the {@link Runner}.
+			* @type {SerializableEvent[]}
+			*/
+			this.events = events;
+			/**
+			* Symbol-like value needed to distinguish when attempting to deserialize
+			* this object (once it's been received over IPC).
+			* @type {Readonly<"SerializableWorkerResult">}
+			*/
+			Object.defineProperty(this, "__type", {
+				value: SERIALIZABLE_RESULT_NAME,
+				enumerable: true,
+				writable: false
+			});
+		}
+		/**
+		* Instantiates a new {@link SerializableWorkerResult}.
+		* @param {...any} args - Args to constructor
+		* @returns {SerializableWorkerResult}
+		*/
+		static create(...args) {
+			return new SerializableWorkerResult(...args);
+		}
+		/**
+		* Serializes each {@link SerializableEvent} in our `events` prop;
+		* makes this object read-only.
+		* @returns {Readonly<SerializableWorkerResult>}
+		*/
+		serialize() {
+			this.events.forEach((event) => {
+				event.serialize();
+			});
+			return Object.freeze(this);
+		}
+		/**
+		* Deserializes a {@link SerializedWorkerResult} into something reporters can
+		* use; calls {@link SerializableEvent.deserialize} on each item in its
+		* `events` prop.
+		* @param {SerializedWorkerResult} obj
+		* @returns {SerializedWorkerResult}
+		*/
+		static deserialize(obj) {
+			obj.events.forEach((event) => {
+				SerializableEvent.deserialize(event);
+			});
+			return obj;
+		}
+		/**
+		* Returns `true` if this is a {@link SerializedWorkerResult} or a
+		* {@link SerializableWorkerResult}.
+		* @param {*} value - A value to check
+		* @returns {boolean} If true, it's deserializable
+		*/
+		static isSerializedWorkerResult(value) {
+			return value instanceof SerializableWorkerResult || type(value) === "object" && value.__type === SERIALIZABLE_RESULT_NAME;
+		}
+	};
+	/**
+	* Represents an event, emitted by a {@link Runner}, which is to be transmitted
+	* over IPC.
+	*
+	* Due to the contents of the event data, it's not possible to send them
+	* verbatim. When received by the main process--and handled by reporters--these
+	* objects are expected to contain {@link Runnable} instances.  This class
+	* provides facilities to perform the translation via serialization and
+	* deserialization.
+	* @private
+	*/
+	var SerializableEvent = class SerializableEvent {
+		/**
+		* Constructs a `SerializableEvent`, throwing if we receive unexpected data.
+		*
+		* Practically, events emitted from `Runner` have a minimum of zero (0)
+		* arguments-- (for example, {@link Runnable.constants.EVENT_RUN_BEGIN}) and a
+		* maximum of two (2) (for example,
+		* {@link Runnable.constants.EVENT_TEST_FAIL}, where the second argument is an
+		* `Error`).  The first argument, if present, is a {@link Runnable}. This
+		* constructor's arguments adhere to this convention.
+		* @param {string} eventName - A non-empty event name.
+		* @param {any} [originalValue] - Some data. Corresponds to extra arguments
+		* passed to `EventEmitter#emit`.
+		* @param {Error} [originalError] - An error, if there's an error.
+		* @throws If `eventName` is empty, or `originalValue` is a non-object.
+		*/
+		constructor(eventName, originalValue, originalError) {
+			if (!eventName) throw createInvalidArgumentTypeError("Empty `eventName` string argument", "eventName", "string");
+			/**
+			* The event name.
+			* @memberof SerializableEvent
+			*/
+			this.eventName = eventName;
+			const originalValueType = type(originalValue);
+			if (originalValueType !== "object" && originalValueType !== "undefined") throw createInvalidArgumentTypeError(`Expected object but received ${originalValueType}`, "originalValue", "object");
+			/**
+			* An error, if present.
+			* @memberof SerializableEvent
+			*/
+			Object.defineProperty(this, "originalError", {
+				value: originalError,
+				enumerable: false
+			});
+			/**
+			* The raw value.
+			*
+			* We don't want this value sent via IPC; making it non-enumerable will do that.
+			*
+			* @memberof SerializableEvent
+			*/
+			Object.defineProperty(this, "originalValue", {
+				value: originalValue,
+				enumerable: false
+			});
+		}
+		/**
+		* In case you hated using `new` (I do).
+		*
+		* @param  {...any} args - Args for {@link SerializableEvent#constructor}.
+		* @returns {SerializableEvent} A new `SerializableEvent`
+		*/
+		static create(...args) {
+			return new SerializableEvent(...args);
+		}
+		/**
+		* Used internally by {@link SerializableEvent#serialize}.
+		* @ignore
+		* @param {Array<object|string>} pairs - List of parent/key tuples to process; modified in-place. This JSDoc type is an approximation
+		* @param {object} parent - Some parent object
+		* @param {string} key - Key to inspect
+		*/
+		static _serialize(pairs, parent, key) {
+			let value = parent[key];
+			let _type = type(value);
+			if (_type === "error") {
+				value = Object.assign(Object.create(null), value, {
+					stack: value.stack,
+					message: value.message,
+					__type: "Error"
+				});
+				parent[key] = value;
+				_type = "object";
+			}
+			switch (_type) {
+				case "object":
+					if (type(value.serialize) === "function") parent[key] = value.serialize();
+					else pairs.push(...Object.keys(value).filter((key$1) => SERIALIZABLE_TYPES.has(type(value[key$1]))).map((key$1) => [value, key$1]));
+					break;
+				case "function":
+					delete parent[key];
+					break;
+				case "array":
+					pairs.push(...value.filter((value$1) => SERIALIZABLE_TYPES.has(type(value$1))).map((value$1, index) => [value$1, index]));
+					break;
+			}
+		}
+		/**
+		* Modifies this object *in place* (for theoretical memory consumption &
+		* performance reasons); serializes `SerializableEvent#originalValue` (placing
+		* the result in `SerializableEvent#data`) and `SerializableEvent#error`.
+		* Freezes this object. The result is an object that can be transmitted over
+		* IPC.
+		* If this quickly becomes unmaintainable, we will want to move towards immutable
+		* objects post-haste.
+		*/
+		serialize() {
+			const originalValue = this.originalValue;
+			const result = Object.assign(Object.create(null), {
+				data: type(originalValue) === "object" && type(originalValue.serialize) === "function" ? originalValue.serialize() : originalValue,
+				error: this.originalError
+			});
+			breakCircularDeps(result.error);
+			const pairs = Object.keys(result).map((key) => [result, key]);
+			const seenPairs = /* @__PURE__ */ new Set();
+			let pair;
+			while (pair = pairs.shift()) {
+				if (seenPairs.has(pair[1])) continue;
+				seenPairs.add(pair[1]);
+				SerializableEvent._serialize(pairs, ...pair);
+			}
+			this.data = result.data;
+			this.error = result.error;
+			return Object.freeze(this);
+		}
+		/**
+		* Used internally by {@link SerializableEvent.deserialize}; creates an `Error`
+		* from an `Error`-like (serialized) object
+		* @ignore
+		* @param {Object} value - An Error-like value
+		* @returns {Error} Real error
+		*/
+		static _deserializeError(value) {
+			const error = new Error(value.message);
+			error.stack = value.stack;
+			Object.assign(error, value);
+			delete error.__type;
+			return error;
+		}
+		/**
+		* Used internally by {@link SerializableEvent.deserialize}; recursively
+		* deserializes an object in-place.
+		* @param {object|Array} parent - Some object or array
+		* @param {string|number} key - Some prop name or array index within `parent`
+		*/
+		static _deserializeObject(parent, key) {
+			if (key === "__proto__") {
+				delete parent[key];
+				return;
+			}
+			const value = parent[key];
+			if (type(key) === "string" && key.startsWith("$$")) {
+				const newKey = key.slice(2);
+				parent[newKey] = () => value;
+				delete parent[key];
+				key = newKey;
+			}
+			if (type(value) === "array") value.forEach((_, idx) => {
+				SerializableEvent._deserializeObject(value, idx);
+			});
+			else if (type(value) === "object") if (value.__type === "Error") parent[key] = SerializableEvent._deserializeError(value);
+			else Object.keys(value).forEach((key$1) => {
+				SerializableEvent._deserializeObject(value, key$1);
+			});
+		}
+		/**
+		* Deserialize value returned from a worker into something more useful.
+		* Does not return the same object.
+		* @todo do this in a loop instead of with recursion (if necessary)
+		* @param {SerializedEvent} obj - Object returned from worker
+		* @returns {SerializedEvent} Deserialized result
+		*/
+		static deserialize(obj) {
+			if (!obj) throw createInvalidArgumentTypeError("Expected value", obj);
+			obj = Object.assign(Object.create(null), obj);
+			if (obj.data) Object.keys(obj.data).forEach((key) => {
+				SerializableEvent._deserializeObject(obj.data, key);
+			});
+			if (obj.error) obj.error = SerializableEvent._deserializeError(obj.error);
+			return obj;
+		}
+	};
+	/**
+	* "Serializes" a value for transmission over IPC as a message.
+	*
+	* If value is an object and has a `serialize()` method, call that method; otherwise return the object and hope for the best.
+	*
+	* @param {*} [value] - A value to serialize
+	*/
+	exports.serialize = function serialize(value) {
+		const result = type(value) === "object" && type(value.serialize) === "function" ? value.serialize() : value;
+		debug("serialized: %O", result);
+		return result;
+	};
+	/**
+	* "Deserializes" a "message" received over IPC.
+	*
+	* This could be expanded with other objects that need deserialization,
+	* but at present time we only care about {@link SerializableWorkerResult} objects.
+	*
+	* @param {*} [value] - A "message" to deserialize
+	*/
+	exports.deserialize = function deserialize(value) {
+		const result = SerializableWorkerResult.isSerializedWorkerResult(value) ? SerializableWorkerResult.deserialize(value) : value;
+		debug("deserialized: %O", result);
+		return result;
+	};
+	exports.SerializableEvent = SerializableEvent;
+	exports.SerializableWorkerResult = SerializableWorkerResult;
+}) });
+
+//#endregion
+export default require_serializer();
+
+export { require_serializer };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/pending.js

@@ -0,0 +1,22 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/pending.js
+var require_pending = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/pending.js": ((exports, module) => {
+	/**
+	@module Pending
+	*/
+	module.exports = Pending;
+	/**
+	* Initialize a new `Pending` error with the given message.
+	*
+	* @param {string} message
+	*/
+	function Pending(message) {
+		this.message = message;
+	}
+}) });
+
+//#endregion
+export default require_pending();
+
+export { require_pending };