@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/base.js

@@ -0,0 +1,417 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_lib } from "../../../../../diff@7.0.0/node_modules/diff/lib/index.js";
+import { require_ms } from "../../../../../ms@2.1.3/node_modules/ms/index.js";
+import { require_utils } from "../utils.js";
+import { require_supports_color } from "../../../../../supports-color@8.1.1/node_modules/supports-color/index.js";
+import { require_log_symbols } from "../../../../../log-symbols@4.1.0/node_modules/log-symbols/index.js";
+import { require_runner } from "../runner.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/base.js
+var require_base = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/base.js": ((exports, module) => {
+	/**
+	* @typedef {import('../runner.js')} Runner
+	* @typedef {import('../test.js')} Test
+	* @typedef {import('../types.d.ts').FullErrorStack} FullErrorStack
+	*/
+	/**
+	* @module Base
+	*/
+	/**
+	* Module dependencies.
+	*/
+	var diff = require_lib();
+	var milliseconds = require_ms();
+	var utils = require_utils();
+	var supportsColor = require_supports_color();
+	var symbols = require_log_symbols();
+	var constants = require_runner().constants;
+	var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+	var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+	const isBrowser = utils.isBrowser();
+	function getBrowserWindowSize() {
+		if ("innerHeight" in global) return [global.innerHeight, global.innerWidth];
+		return [640, 480];
+	}
+	/**
+	* Expose `Base`.
+	*/
+	exports = module.exports = Base;
+	/**
+	* Check if both stdio streams are associated with a tty.
+	*/
+	var isatty = isBrowser || process.stdout.isTTY && process.stderr.isTTY;
+	/**
+	* Save log references to avoid tests interfering (see GH-3604).
+	*/
+	var consoleLog = console.log;
+	/**
+	* Enable coloring by default, except in the browser interface.
+	*/
+	exports.useColors = !isBrowser && (supportsColor.stdout || process.env.MOCHA_COLORS !== void 0);
+	/**
+	* Inline diffs instead of +/-
+	*/
+	exports.inlineDiffs = false;
+	/**
+	* Truncate diffs longer than this value to avoid slow performance
+	*/
+	exports.maxDiffSize = 8192;
+	/**
+	* Default color map.
+	*/
+	exports.colors = {
+		pass: 90,
+		fail: 31,
+		"bright pass": 92,
+		"bright fail": 91,
+		"bright yellow": 93,
+		pending: 36,
+		suite: 0,
+		"error title": 0,
+		"error message": 31,
+		"error stack": 90,
+		checkmark: 32,
+		fast: 90,
+		medium: 33,
+		slow: 31,
+		green: 32,
+		light: 90,
+		"diff gutter": 90,
+		"diff added": 32,
+		"diff removed": 31,
+		"diff added inline": "30;42",
+		"diff removed inline": "30;41"
+	};
+	/**
+	* Default symbol map.
+	*/
+	exports.symbols = {
+		ok: symbols.success,
+		err: symbols.error,
+		dot: ".",
+		comma: ",",
+		bang: "!"
+	};
+	/**
+	* Color `str` with the given `type`,
+	* allowing colors to be disabled,
+	* as well as user-defined color
+	* schemes.
+	*
+	* @private
+	* @param {string} type
+	* @param {string} str
+	* @return {string}
+	*/
+	var color = exports.color = function(type, str) {
+		if (!exports.useColors) return String(str);
+		return "\x1B[" + exports.colors[type] + "m" + str + "\x1B[0m";
+	};
+	/**
+	* Expose term window size, with some defaults for when stderr is not a tty.
+	*/
+	exports.window = { width: 75 };
+	if (isatty) if (isBrowser) exports.window.width = getBrowserWindowSize()[1];
+	else exports.window.width = process.stdout.getWindowSize(1)[0];
+	/**
+	* Expose some basic cursor interactions that are common among reporters.
+	*/
+	exports.cursor = {
+		hide: function() {
+			isatty && process.stdout.write("\x1B[?25l");
+		},
+		show: function() {
+			isatty && process.stdout.write("\x1B[?25h");
+		},
+		deleteLine: function() {
+			isatty && process.stdout.write("\x1B[2K");
+		},
+		beginningOfLine: function() {
+			isatty && process.stdout.write("\x1B[0G");
+		},
+		CR: function() {
+			if (isatty) {
+				exports.cursor.deleteLine();
+				exports.cursor.beginningOfLine();
+			} else process.stdout.write("\r");
+		}
+	};
+	var showDiff = exports.showDiff = function(err) {
+		return err && err.showDiff !== false && sameType(err.actual, err.expected) && err.expected !== void 0;
+	};
+	function stringifyDiffObjs(err) {
+		if (!utils.isString(err.actual) || !utils.isString(err.expected)) {
+			err.actual = utils.stringify(err.actual);
+			err.expected = utils.stringify(err.expected);
+		}
+	}
+	/**
+	* Returns a diff between 2 strings with coloured ANSI output.
+	*
+	* @description
+	* The diff will be either inline or unified dependent on the value
+	* of `Base.inlineDiff`.
+	*
+	* @param {string} actual
+	* @param {string} expected
+	* @return {string} Diff
+	*/
+	var generateDiff = exports.generateDiff = function(actual, expected) {
+		try {
+			var maxLen = exports.maxDiffSize;
+			var skipped = 0;
+			if (maxLen > 0) {
+				skipped = Math.max(actual.length - maxLen, expected.length - maxLen);
+				actual = actual.slice(0, maxLen);
+				expected = expected.slice(0, maxLen);
+			}
+			let result = exports.inlineDiffs ? inlineDiff(actual, expected) : unifiedDiff(actual, expected);
+			if (skipped > 0) result = `${result}\n      [mocha] output truncated to ${maxLen} characters, see "maxDiffSize" reporter-option\n`;
+			return result;
+		} catch (err) {
+			return "\n      " + color("diff added", "+ expected") + " " + color("diff removed", "- actual:  failed to generate Mocha diff") + "\n";
+		}
+	};
+	/**
+	* Traverses err.cause and returns all stack traces
+	*
+	* @private
+	* @param {Error} err
+	* @param {Set<Error>} [seen]
+	* @return {FullErrorStack}
+	*/
+	var getFullErrorStack = function(err, seen) {
+		if (seen && seen.has(err)) return {
+			message: "",
+			msg: "<circular>",
+			stack: ""
+		};
+		var message;
+		if (typeof err.inspect === "function") message = err.inspect() + "";
+		else if (err.message && typeof err.message.toString === "function") message = err.message + "";
+		else message = "";
+		var msg;
+		var stack = err.stack || message;
+		var index = message ? stack.indexOf(message) : -1;
+		if (index === -1) msg = message;
+		else {
+			index += message.length;
+			msg = stack.slice(0, index);
+			stack = stack.slice(index + 1);
+			if (err.cause) {
+				seen = seen || /* @__PURE__ */ new Set();
+				seen.add(err);
+				const causeStack = getFullErrorStack(err.cause, seen);
+				stack += "\n   Caused by: " + causeStack.msg + (causeStack.stack ? "\n" + causeStack.stack : "");
+			}
+		}
+		return {
+			message,
+			msg,
+			stack
+		};
+	};
+	/**
+	* Outputs the given `failures` as a list.
+	*
+	* @public
+	* @memberof Mocha.reporters.Base
+	* @variation 1
+	* @param {Object[]} failures - Each is Test instance with corresponding
+	*     Error property
+	*/
+	exports.list = function(failures) {
+		var multipleErr, multipleTest;
+		Base.consoleLog();
+		failures.forEach(function(test, i) {
+			var fmt = color("error title", "  %s) %s:\n") + color("error message", "     %s") + color("error stack", "\n%s\n");
+			var err;
+			if (test.err && test.err.multiple) {
+				if (multipleTest !== test) {
+					multipleTest = test;
+					multipleErr = [test.err].concat(test.err.multiple);
+				}
+				err = multipleErr.shift();
+			} else err = test.err;
+			var { message, msg, stack } = getFullErrorStack(err);
+			if (err.uncaught) msg = "Uncaught " + msg;
+			if (!exports.hideDiff && showDiff(err)) {
+				stringifyDiffObjs(err);
+				fmt = color("error title", "  %s) %s:\n%s") + color("error stack", "\n%s\n");
+				var match = message.match(/^([^:]+): expected/);
+				msg = "\n      " + color("error message", match ? match[1] : msg);
+				msg += generateDiff(err.actual, err.expected);
+			}
+			stack = stack.replace(/^/gm, "  ");
+			var testTitle = "";
+			test.titlePath().forEach(function(str, index) {
+				if (index !== 0) testTitle += "\n     ";
+				for (var i$1 = 0; i$1 < index; i$1++) testTitle += "  ";
+				testTitle += str;
+			});
+			Base.consoleLog(fmt, i + 1, testTitle, msg, stack);
+		});
+	};
+	/**
+	* Constructs a new `Base` reporter instance.
+	*
+	* @description
+	* All other reporters generally inherit from this reporter.
+	*
+	* @public
+	* @class
+	* @memberof Mocha.reporters
+	* @param {Runner} runner - Instance triggers reporter actions.
+	* @param {Object} [options] - runner options
+	*/
+	function Base(runner, options) {
+		var failures = this.failures = [];
+		if (!runner) throw new TypeError("Missing runner argument");
+		this.options = options || {};
+		this.runner = runner;
+		this.stats = runner.stats;
+		var maxDiffSizeOpt = this.options.reporterOption && this.options.reporterOption.maxDiffSize;
+		if (maxDiffSizeOpt !== void 0 && !isNaN(Number(maxDiffSizeOpt))) exports.maxDiffSize = Number(maxDiffSizeOpt);
+		runner.on(EVENT_TEST_PASS, function(test) {
+			if (test.duration > test.slow()) test.speed = "slow";
+			else if (test.duration > test.slow() / 2) test.speed = "medium";
+			else test.speed = "fast";
+		});
+		runner.on(EVENT_TEST_FAIL, function(test, err) {
+			if (showDiff(err)) stringifyDiffObjs(err);
+			if (test.err && err instanceof Error) test.err.multiple = (test.err.multiple || []).concat(err);
+			else test.err = err;
+			failures.push(test);
+		});
+	}
+	/**
+	* Outputs common epilogue used by many of the bundled reporters.
+	*
+	* @public
+	* @memberof Mocha.reporters
+	*/
+	Base.prototype.epilogue = function() {
+		var stats = this.stats;
+		var fmt;
+		Base.consoleLog();
+		fmt = color("bright pass", " ") + color("green", " %d passing") + color("light", " (%s)");
+		Base.consoleLog(fmt, stats.passes || 0, milliseconds(stats.duration));
+		if (stats.pending) {
+			fmt = color("pending", " ") + color("pending", " %d pending");
+			Base.consoleLog(fmt, stats.pending);
+		}
+		if (stats.failures) {
+			fmt = color("fail", "  %d failing");
+			Base.consoleLog(fmt, stats.failures);
+			Base.list(this.failures);
+			Base.consoleLog();
+		}
+		Base.consoleLog();
+	};
+	/**
+	* Pads the given `str` to `len`.
+	*
+	* @private
+	* @param {string} str
+	* @param {string} len
+	* @return {string}
+	*/
+	function pad(str, len) {
+		str = String(str);
+		return Array(len - str.length + 1).join(" ") + str;
+	}
+	/**
+	* Returns inline diff between 2 strings with coloured ANSI output.
+	*
+	* @private
+	* @param {String} actual
+	* @param {String} expected
+	* @return {string} Diff
+	*/
+	function inlineDiff(actual, expected) {
+		var msg = errorDiff(actual, expected);
+		var lines = msg.split("\n");
+		if (lines.length > 4) {
+			var width = String(lines.length).length;
+			msg = lines.map(function(str, i) {
+				return pad(++i, width) + " | " + str;
+			}).join("\n");
+		}
+		msg = "\n" + color("diff removed inline", "actual") + " " + color("diff added inline", "expected") + "\n\n" + msg + "\n";
+		msg = msg.replace(/^/gm, "      ");
+		return msg;
+	}
+	/**
+	* Returns unified diff between two strings with coloured ANSI output.
+	*
+	* @private
+	* @param {String} actual
+	* @param {String} expected
+	* @return {string} The diff.
+	*/
+	function unifiedDiff(actual, expected) {
+		var indent = "      ";
+		function cleanUp(line) {
+			if (line[0] === "+") return indent + colorLines("diff added", line);
+			if (line[0] === "-") return indent + colorLines("diff removed", line);
+			if (line.match(/@@/)) return "--";
+			if (line.match(/\\ No newline/)) return null;
+			return indent + line;
+		}
+		function notBlank(line) {
+			return typeof line !== "undefined" && line !== null;
+		}
+		var lines = diff.createPatch("string", actual, expected).split("\n").splice(5);
+		return "\n      " + colorLines("diff added", "+ expected") + " " + colorLines("diff removed", "- actual") + "\n\n" + lines.map(cleanUp).filter(notBlank).join("\n");
+	}
+	/**
+	* Returns character diff for `err`.
+	*
+	* @private
+	* @param {String} actual
+	* @param {String} expected
+	* @return {string} the diff
+	*/
+	function errorDiff(actual, expected) {
+		return diff.diffWordsWithSpace(actual, expected).map(function(str) {
+			if (str.added) return colorLines("diff added inline", str.value);
+			if (str.removed) return colorLines("diff removed inline", str.value);
+			return str.value;
+		}).join("");
+	}
+	/**
+	* Colors lines for `str`, using the color `name`.
+	*
+	* @private
+	* @param {string} name
+	* @param {string} str
+	* @return {string}
+	*/
+	function colorLines(name, str) {
+		return str.split("\n").map(function(str$1) {
+			return color(name, str$1);
+		}).join("\n");
+	}
+	/**
+	* Object#toString reference.
+	*/
+	var objToString = Object.prototype.toString;
+	/**
+	* Checks that a / b have the same type.
+	*
+	* @private
+	* @param {Object} a
+	* @param {Object} b
+	* @return {boolean}
+	*/
+	function sameType(a, b) {
+		return objToString.call(a) === objToString.call(b);
+	}
+	Base.consoleLog = consoleLog;
+	Base.abstract = true;
+}) });
+
+//#endregion
+export default require_base();
+
+export { require_base };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/doc.js

@@ -0,0 +1,79 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../utils.js";
+import { require_runner } from "../runner.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/doc.js
+var require_doc = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/doc.js": ((exports, module) => {
+	/**
+	* @typedef {import('../runner.js')} Runner
+	*/
+	/**
+	* @module Doc
+	*/
+	/**
+	* Module dependencies.
+	*/
+	var Base = require_base();
+	var utils = require_utils();
+	var constants = require_runner().constants;
+	var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+	var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+	var EVENT_SUITE_BEGIN = constants.EVENT_SUITE_BEGIN;
+	var EVENT_SUITE_END = constants.EVENT_SUITE_END;
+	/**
+	* Expose `Doc`.
+	*/
+	exports = module.exports = Doc;
+	/**
+	* Constructs a new `Doc` reporter instance.
+	*
+	* @public
+	* @class
+	* @memberof Mocha.reporters
+	* @extends Mocha.reporters.Base
+	* @param {Runner} runner - Instance triggers reporter actions.
+	* @param {Object} [options] - runner options
+	*/
+	function Doc(runner, options) {
+		Base.call(this, runner, options);
+		var indents = 2;
+		function indent() {
+			return Array(indents).join("  ");
+		}
+		runner.on(EVENT_SUITE_BEGIN, function(suite) {
+			if (suite.root) return;
+			++indents;
+			Base.consoleLog("%s<section class=\"suite\">", indent());
+			++indents;
+			Base.consoleLog("%s<h1>%s</h1>", indent(), utils.escape(suite.title));
+			Base.consoleLog("%s<dl>", indent());
+		});
+		runner.on(EVENT_SUITE_END, function(suite) {
+			if (suite.root) return;
+			Base.consoleLog("%s</dl>", indent());
+			--indents;
+			Base.consoleLog("%s</section>", indent());
+			--indents;
+		});
+		runner.on(EVENT_TEST_PASS, function(test) {
+			Base.consoleLog("%s  <dt>%s</dt>", indent(), utils.escape(test.title));
+			Base.consoleLog("%s  <dt>%s</dt>", indent(), utils.escape(test.file));
+			var code = utils.escape(utils.clean(test.body));
+			Base.consoleLog("%s  <dd><pre><code>%s</code></pre></dd>", indent(), code);
+		});
+		runner.on(EVENT_TEST_FAIL, function(test, err) {
+			Base.consoleLog("%s  <dt class=\"error\">%s</dt>", indent(), utils.escape(test.title));
+			Base.consoleLog("%s  <dt class=\"error\">%s</dt>", indent(), utils.escape(test.file));
+			var code = utils.escape(utils.clean(test.body));
+			Base.consoleLog("%s  <dd class=\"error\"><pre><code>%s</code></pre></dd>", indent(), code);
+			Base.consoleLog("%s  <dd class=\"error\">%s</dd>", indent(), utils.escape(err));
+		});
+	}
+	Doc.description = "HTML documentation";
+}) });
+
+//#endregion
+export default require_doc();
+
+export { require_doc };

package/dist/node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/dot.js

@@ -0,0 +1,75 @@
+import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../utils.js";
+import { require_runner } from "../runner.js";
+import { require_base } from "./base.js";
+
+//#region ../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/dot.js
+var require_dot = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/lib/reporters/dot.js": ((exports, module) => {
+	/**
+	* @typedef {import('../runner.js')} Runner
+	*/
+	/**
+	* @module Dot
+	*/
+	/**
+	* Module dependencies.
+	*/
+	var Base = require_base();
+	var inherits = require_utils().inherits;
+	var constants = require_runner().constants;
+	var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+	var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
+	var EVENT_RUN_BEGIN = constants.EVENT_RUN_BEGIN;
+	var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
+	var EVENT_RUN_END = constants.EVENT_RUN_END;
+	/**
+	* Expose `Dot`.
+	*/
+	exports = module.exports = Dot;
+	/**
+	* Constructs a new `Dot` reporter instance.
+	*
+	* @public
+	* @class
+	* @memberof Mocha.reporters
+	* @extends Mocha.reporters.Base
+	* @param {Runner} runner - Instance triggers reporter actions.
+	* @param {Object} [options] - runner options
+	*/
+	function Dot(runner, options) {
+		Base.call(this, runner, options);
+		var self = this;
+		var width = Base.window.width * .75 | 0;
+		var n = -1;
+		runner.on(EVENT_RUN_BEGIN, function() {
+			process.stdout.write("\n");
+		});
+		runner.on(EVENT_TEST_PENDING, function() {
+			if (++n % width === 0) process.stdout.write("\n  ");
+			process.stdout.write(Base.color("pending", Base.symbols.comma));
+		});
+		runner.on(EVENT_TEST_PASS, function(test) {
+			if (++n % width === 0) process.stdout.write("\n  ");
+			if (test.speed === "slow") process.stdout.write(Base.color("bright yellow", Base.symbols.dot));
+			else process.stdout.write(Base.color(test.speed, Base.symbols.dot));
+		});
+		runner.on(EVENT_TEST_FAIL, function() {
+			if (++n % width === 0) process.stdout.write("\n  ");
+			process.stdout.write(Base.color("fail", Base.symbols.bang));
+		});
+		runner.once(EVENT_RUN_END, function() {
+			process.stdout.write("\n");
+			self.epilogue();
+		});
+	}
+	/**
+	* Inherit from `Base.prototype`.
+	*/
+	inherits(Dot, Base);
+	Dot.description = "dot matrix representation";
+}) });
+
+//#endregion
+export default require_dot();
+
+export { require_dot };