@eggjs/mock 6.1.0-beta.3 → 6.1.0-beta.4

package/dist/_virtual/rolldown_runtime.js

@@ -1,7 +1,30 @@
 import { createRequire } from "node:module";
 
 //#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-export { __require };
+export { __commonJS, __require, __toESM };

package/dist/bootstrap.d.ts

@@ -6,4 +6,4 @@ import { strict as assert } from "node:assert";
 //#region src/bootstrap.d.ts
 declare const app: ApplicationUnittest;
 //#endregion
-export { ApplicationUnittest as MockApplication, app, assert, getBootstrapApp, proxyMock as mm, proxyMock as mock };
+export { type ApplicationUnittest as MockApplication, app, assert, getBootstrapApp, proxyMock as mm, proxyMock as mock };

package/dist/bootstrap.js

@@ -11,4 +11,4 @@ if (readJSONSync(path.join(options.baseDir || process.cwd(), "package.json")).eg
 const app = setupApp();
 
 //#endregion
-export { MockApplication, app, assert, getBootstrapApp, src_default as mm, proxyMock as mock };
+export { app, assert, getBootstrapApp, src_default as mm, proxyMock as mock };

package/dist/index.js

@@ -1,5 +1,4 @@
 import { createCluster } from "./lib/cluster.js";
-import "./app/extend/application.js";
 import { createApp } from "./lib/app.js";
 import { restore as restore$1 } from "./lib/restore.js";
 import { setGetAppCallback } from "./lib/app_handler.js";

package/dist/inject_mocha.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/inject_mocha.js

@@ -0,0 +1,35 @@
+import { __require, __toESM } from "./_virtual/rolldown_runtime.js";
+import { injectContext } from "./lib/inject_context.js";
+import { require_mocha } from "./node_modules/.pnpm/mocha@11.7.2/node_modules/mocha/index.js";
+import { debuglog } from "node:util";
+import { getRequire } from "@eggjs/utils";
+
+//#region src/inject_mocha.ts
+var import_mocha = /* @__PURE__ */ __toESM(require_mocha(), 1);
+const debug = debuglog("egg/mock/inject_mocha");
+/**
+* Find active node mocha instances.
+*/
+function findNodeJSMocha() {
+	let children;
+	if (typeof __require === "function") children = __require.cache || {};
+	else {
+		children = getRequire().cache || {};
+		debug("createRequire on esm");
+	}
+	return Object.keys(children).filter(function(child) {
+		const val = children[child].exports;
+		return typeof val === "function" && val.name === "Mocha";
+	}).map(function(child) {
+		return children[child].exports;
+	});
+}
+const modules = findNodeJSMocha();
+debug("modules length: %s", modules.length);
+for (const module of modules) {
+	if (!module) continue;
+	injectContext(module);
+}
+
+//#endregion
+export {  };

package/dist/node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js

@@ -0,0 +1,142 @@
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+import { require_color_convert } from "../../../color-convert@2.0.1/node_modules/color-convert/index.js";
+
+//#region ../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js
+var require_ansi_styles = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js": ((exports, module) => {
+	const wrapAnsi16 = (fn, offset) => (...args) => {
+		return `\u001B[${fn(...args) + offset}m`;
+	};
+	const wrapAnsi256 = (fn, offset) => (...args) => {
+		const code = fn(...args);
+		return `\u001B[${38 + offset};5;${code}m`;
+	};
+	const wrapAnsi16m = (fn, offset) => (...args) => {
+		const rgb = fn(...args);
+		return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+	};
+	const ansi2ansi = (n) => n;
+	const rgb2rgb = (r, g, b) => [
+		r,
+		g,
+		b
+	];
+	const setLazyProperty = (object, property, get) => {
+		Object.defineProperty(object, property, {
+			get: () => {
+				const value = get();
+				Object.defineProperty(object, property, {
+					value,
+					enumerable: true,
+					configurable: true
+				});
+				return value;
+			},
+			enumerable: true,
+			configurable: true
+		});
+	};
+	/** @type {typeof import('color-convert')} */
+	let colorConvert;
+	const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+		if (colorConvert === void 0) colorConvert = require_color_convert();
+		const offset = isBackground ? 10 : 0;
+		const styles = {};
+		for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+			const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+			if (sourceSpace === targetSpace) styles[name] = wrap(identity, offset);
+			else if (typeof suite === "object") styles[name] = wrap(suite[targetSpace], offset);
+		}
+		return styles;
+	};
+	function assembleStyles() {
+		const codes = /* @__PURE__ */ new Map();
+		const styles = {
+			modifier: {
+				reset: [0, 0],
+				bold: [1, 22],
+				dim: [2, 22],
+				italic: [3, 23],
+				underline: [4, 24],
+				inverse: [7, 27],
+				hidden: [8, 28],
+				strikethrough: [9, 29]
+			},
+			color: {
+				black: [30, 39],
+				red: [31, 39],
+				green: [32, 39],
+				yellow: [33, 39],
+				blue: [34, 39],
+				magenta: [35, 39],
+				cyan: [36, 39],
+				white: [37, 39],
+				blackBright: [90, 39],
+				redBright: [91, 39],
+				greenBright: [92, 39],
+				yellowBright: [93, 39],
+				blueBright: [94, 39],
+				magentaBright: [95, 39],
+				cyanBright: [96, 39],
+				whiteBright: [97, 39]
+			},
+			bgColor: {
+				bgBlack: [40, 49],
+				bgRed: [41, 49],
+				bgGreen: [42, 49],
+				bgYellow: [43, 49],
+				bgBlue: [44, 49],
+				bgMagenta: [45, 49],
+				bgCyan: [46, 49],
+				bgWhite: [47, 49],
+				bgBlackBright: [100, 49],
+				bgRedBright: [101, 49],
+				bgGreenBright: [102, 49],
+				bgYellowBright: [103, 49],
+				bgBlueBright: [104, 49],
+				bgMagentaBright: [105, 49],
+				bgCyanBright: [106, 49],
+				bgWhiteBright: [107, 49]
+			}
+		};
+		styles.color.gray = styles.color.blackBright;
+		styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+		styles.color.grey = styles.color.blackBright;
+		styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+		for (const [groupName, group] of Object.entries(styles)) {
+			for (const [styleName, style] of Object.entries(group)) {
+				styles[styleName] = {
+					open: `\u001B[${style[0]}m`,
+					close: `\u001B[${style[1]}m`
+				};
+				group[styleName] = styles[styleName];
+				codes.set(style[0], style[1]);
+			}
+			Object.defineProperty(styles, groupName, {
+				value: group,
+				enumerable: false
+			});
+		}
+		Object.defineProperty(styles, "codes", {
+			value: codes,
+			enumerable: false
+		});
+		styles.color.close = "\x1B[39m";
+		styles.bgColor.close = "\x1B[49m";
+		setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+		setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+		setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+		setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+		setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+		setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+		return styles;
+	}
+	Object.defineProperty(module, "exports", {
+		enumerable: true,
+		get: assembleStyles
+	});
+}) });
+
+//#endregion
+export default require_ansi_styles();
+
+export { require_ansi_styles };

package/dist/node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js

@@ -0,0 +1,157 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+import { require_ansi_styles } from "../../../../ansi-styles@4.3.0/node_modules/ansi-styles/index.js";
+import { require_supports_color } from "../../../../supports-color@7.2.0/node_modules/supports-color/index.js";
+import { require_util } from "./util.js";
+import { require_templates } from "./templates.js";
+
+//#region ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js
+var require_source = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js": ((exports, module) => {
+	const ansiStyles = require_ansi_styles();
+	const { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+	const { stringReplaceAll, stringEncaseCRLFWithFirstIndex } = require_util();
+	const { isArray } = Array;
+	const levelMapping = [
+		"ansi",
+		"ansi",
+		"ansi256",
+		"ansi16m"
+	];
+	const styles = Object.create(null);
+	const applyOptions = (object, options = {}) => {
+		if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+		const colorLevel = stdoutColor ? stdoutColor.level : 0;
+		object.level = options.level === void 0 ? colorLevel : options.level;
+	};
+	var ChalkClass = class {
+		constructor(options) {
+			return chalkFactory(options);
+		}
+	};
+	const chalkFactory = (options) => {
+		const chalk$1 = {};
+		applyOptions(chalk$1, options);
+		chalk$1.template = (...arguments_) => chalkTag(chalk$1.template, ...arguments_);
+		Object.setPrototypeOf(chalk$1, Chalk.prototype);
+		Object.setPrototypeOf(chalk$1.template, chalk$1);
+		chalk$1.template.constructor = () => {
+			throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+		};
+		chalk$1.template.Instance = ChalkClass;
+		return chalk$1.template;
+	};
+	function Chalk(options) {
+		return chalkFactory(options);
+	}
+	for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+		const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+		Object.defineProperty(this, styleName, { value: builder });
+		return builder;
+	} };
+	styles.visible = { get() {
+		const builder = createBuilder(this, this._styler, true);
+		Object.defineProperty(this, "visible", { value: builder });
+		return builder;
+	} };
+	const usedModels = [
+		"rgb",
+		"hex",
+		"keyword",
+		"hsl",
+		"hsv",
+		"hwb",
+		"ansi",
+		"ansi256"
+	];
+	for (const model of usedModels) styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+			return createBuilder(this, styler, this._isEmpty);
+		};
+	} };
+	for (const model of usedModels) {
+		const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+		styles[bgModel] = { get() {
+			const { level } = this;
+			return function(...arguments_) {
+				const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		} };
+	}
+	const proto = Object.defineProperties(() => {}, {
+		...styles,
+		level: {
+			enumerable: true,
+			get() {
+				return this._generator.level;
+			},
+			set(level) {
+				this._generator.level = level;
+			}
+		}
+	});
+	const createStyler = (open, close, parent) => {
+		let openAll;
+		let closeAll;
+		if (parent === void 0) {
+			openAll = open;
+			closeAll = close;
+		} else {
+			openAll = parent.openAll + open;
+			closeAll = close + parent.closeAll;
+		}
+		return {
+			open,
+			close,
+			openAll,
+			closeAll,
+			parent
+		};
+	};
+	const createBuilder = (self, _styler, _isEmpty) => {
+		const builder = (...arguments_) => {
+			if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) return applyStyle(builder, chalkTag(builder, ...arguments_));
+			return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+		};
+		Object.setPrototypeOf(builder, proto);
+		builder._generator = self;
+		builder._styler = _styler;
+		builder._isEmpty = _isEmpty;
+		return builder;
+	};
+	const applyStyle = (self, string) => {
+		if (self.level <= 0 || !string) return self._isEmpty ? "" : string;
+		let styler = self._styler;
+		if (styler === void 0) return string;
+		const { openAll, closeAll } = styler;
+		if (string.indexOf("\x1B") !== -1) while (styler !== void 0) {
+			string = stringReplaceAll(string, styler.close, styler.open);
+			styler = styler.parent;
+		}
+		const lfIndex = string.indexOf("\n");
+		if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+		return openAll + string + closeAll;
+	};
+	let template;
+	const chalkTag = (chalk$1, ...strings) => {
+		const [firstString] = strings;
+		if (!isArray(firstString) || !isArray(firstString.raw)) return strings.join(" ");
+		const arguments_ = strings.slice(1);
+		const parts = [firstString.raw[0]];
+		for (let i = 1; i < firstString.length; i++) parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), String(firstString.raw[i]));
+		if (template === void 0) template = require_templates();
+		return template(chalk$1, parts.join(""));
+	};
+	Object.defineProperties(Chalk.prototype, styles);
+	const chalk = Chalk();
+	chalk.supportsColor = stdoutColor;
+	chalk.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+	chalk.stderr.supportsColor = stderrColor;
+	module.exports = chalk;
+}) });
+
+//#endregion
+export default require_source();
+
+export { require_source };

package/dist/node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js

@@ -0,0 +1,97 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js
+var require_templates = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js": ((exports, module) => {
+	const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+	const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+	const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+	const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+	const ESCAPES = new Map([
+		["n", "\n"],
+		["r", "\r"],
+		["t", "	"],
+		["b", "\b"],
+		["f", "\f"],
+		["v", "\v"],
+		["0", "\0"],
+		["\\", "\\"],
+		["e", "\x1B"],
+		["a", "\x07"]
+	]);
+	function unescape(c) {
+		const u = c[0] === "u";
+		const bracket = c[1] === "{";
+		if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) return String.fromCharCode(parseInt(c.slice(1), 16));
+		if (u && bracket) return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+		return ESCAPES.get(c) || c;
+	}
+	function parseArguments(name, arguments_) {
+		const results = [];
+		const chunks = arguments_.trim().split(/\s*,\s*/g);
+		let matches;
+		for (const chunk of chunks) {
+			const number = Number(chunk);
+			if (!Number.isNaN(number)) results.push(number);
+			else if (matches = chunk.match(STRING_REGEX)) results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+			else throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+		}
+		return results;
+	}
+	function parseStyle(style) {
+		STYLE_REGEX.lastIndex = 0;
+		const results = [];
+		let matches;
+		while ((matches = STYLE_REGEX.exec(style)) !== null) {
+			const name = matches[1];
+			if (matches[2]) {
+				const args = parseArguments(name, matches[2]);
+				results.push([name].concat(args));
+			} else results.push([name]);
+		}
+		return results;
+	}
+	function buildStyle(chalk, styles) {
+		const enabled = {};
+		for (const layer of styles) for (const style of layer.styles) enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		let current = chalk;
+		for (const [styleName, styles$1] of Object.entries(enabled)) {
+			if (!Array.isArray(styles$1)) continue;
+			if (!(styleName in current)) throw new Error(`Unknown Chalk style: ${styleName}`);
+			current = styles$1.length > 0 ? current[styleName](...styles$1) : current[styleName];
+		}
+		return current;
+	}
+	module.exports = (chalk, temporary) => {
+		const styles = [];
+		const chunks = [];
+		let chunk = [];
+		temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+			if (escapeCharacter) chunk.push(unescape(escapeCharacter));
+			else if (style) {
+				const string = chunk.join("");
+				chunk = [];
+				chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
+				styles.push({
+					inverse,
+					styles: parseStyle(style)
+				});
+			} else if (close) {
+				if (styles.length === 0) throw new Error("Found extraneous } in Chalk template literal");
+				chunks.push(buildStyle(chalk, styles)(chunk.join("")));
+				chunk = [];
+				styles.pop();
+			} else chunk.push(character);
+		});
+		chunks.push(chunk.join(""));
+		if (styles.length > 0) {
+			const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+			throw new Error(errMessage);
+		}
+		return chunks.join("");
+	};
+}) });
+
+//#endregion
+export default require_templates();
+
+export { require_templates };

package/dist/node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js

@@ -0,0 +1,40 @@
+import { __commonJS } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js
+var require_util = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js": ((exports, module) => {
+	const stringReplaceAll = (string, substring, replacer) => {
+		let index = string.indexOf(substring);
+		if (index === -1) return string;
+		const substringLength = substring.length;
+		let endIndex = 0;
+		let returnValue = "";
+		do {
+			returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+			endIndex = index + substringLength;
+			index = string.indexOf(substring, endIndex);
+		} while (index !== -1);
+		returnValue += string.substr(endIndex);
+		return returnValue;
+	};
+	const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+		let endIndex = 0;
+		let returnValue = "";
+		do {
+			const gotCR = string[index - 1] === "\r";
+			returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+			endIndex = index + 1;
+			index = string.indexOf("\n", endIndex);
+		} while (index !== -1);
+		returnValue += string.substr(endIndex);
+		return returnValue;
+	};
+	module.exports = {
+		stringReplaceAll,
+		stringEncaseCRLFWithFirstIndex
+	};
+}) });
+
+//#endregion
+export default require_util();
+
+export { require_util };