@eggjs/mock 6.0.6 → 6.1.0-beta.10

package/{src/lib/types.ts → dist/lib/types.d.ts}

@@ -1,55 +1,49 @@
-export interface MockOptions {
+import { MockHttpClientMethod, MockResponseCallbackOptions, MockResultFunction, MockResultOptions, ResultObject } from "./mock_httpclient.js";
+import { MockAgent } from "urllib";
+
+//#region src/lib/types.d.ts
+interface MockOptions {
   /**
    * The directory of the application
    */
   baseDir?: string;
-
   /**
    * Custom you plugins
    */
   plugins?: any;
-
   /**
    * The directory of the egg framework
    *
    * Set to `true` to use the current directory as framework directory
    */
   framework?: string | boolean;
-
   /**
    * current test on plugin
    */
   plugin?: boolean;
-
   /**
-   * @deprecated please use framework instead
+   * @deprecated please use `framework` instead
    */
   customEgg?: string | boolean;
-
   /**
    * Cache application based on baseDir
    */
   cache?: boolean;
-
   /**
    * Switch on process coverage, but it'll be slower
    */
   coverage?: boolean;
-
   /**
    * Remove $baseDir/logs and $baseDir/run before start, default is `true`
    */
   clean?: boolean;
-
   /**
    * default options.mockCtxStorage value on each mockContext
    */
   mockCtxStorage?: boolean;
-
   beforeInit?: (app: any) => Promise<void>;
 }
-
-export interface MockClusterOptions extends MockOptions {
+interface MockClusterOptions extends MockOptions {
   workers?: number | string;
   cache?: boolean;
   port?: number;
@@ -59,31 +53,20 @@ export interface MockClusterOptions extends MockOptions {
   opt?: object;
   startMode?: 'process' | 'worker_threads';
 }
-
 /**
  * @deprecated please use MockOptions instead
  * keep this for compatible
  */
-export type MockOption = MockOptions;
-
-export interface MockApplicationOptions extends MockOptions {
+type MockOption = MockOptions;
+interface MockApplicationOptions extends MockOptions {
   baseDir: string;
   framework: string;
   clusterPort?: number;
 }
-
-export interface MockClusterApplicationOptions extends MockClusterOptions {
+interface MockClusterApplicationOptions extends MockClusterOptions {
   baseDir: string;
   framework: string;
   port: number;
 }
-
-export type {
-  MockResultOptions, ResultObject,
-  MockResponseCallbackOptions, MockResultFunction,
-  MockHttpClientMethod,
-} from './mock_httpclient.js';
-
-export type {
-  MockAgent,
-} from 'urllib';
+//#endregion
+export { type MockAgent, MockApplicationOptions, MockClusterApplicationOptions, MockClusterOptions, type MockHttpClientMethod, MockOption, MockOptions, type MockResponseCallbackOptions, type MockResultFunction, type MockResultOptions, type ResultObject };

package/dist/lib/types.js

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

package/dist/lib/utils.d.ts

@@ -0,0 +1,12 @@
+//#region src/lib/utils.d.ts
+declare function getSourceDirname(): string;
+declare function sleep(delay: number): Promise<void>;
+declare function rimraf(filepath: string): Promise<void>;
+declare function rimrafSync(filepath: string): void;
+declare function getProperty(target: any, prop: PropertyKey): any;
+declare function getEggOptions(): {
+  baseDir: string;
+  framework: string | undefined;
+};
+//#endregion
+export { getEggOptions, getProperty, getSourceDirname, rimraf, rimrafSync, sleep };

package/dist/lib/utils.js

@@ -0,0 +1,40 @@
+import path from "node:path";
+import { rmSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { scheduler } from "node:timers/promises";
+
+//#region src/lib/utils.ts
+function getSourceDirname() {
+	if (typeof __dirname !== "undefined") return path.dirname(__dirname);
+	return path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+}
+async function sleep(delay) {
+	await scheduler.wait(delay);
+}
+async function rimraf(filepath) {
+	await rm(filepath, {
+		force: true,
+		recursive: true
+	});
+}
+function rimrafSync(filepath) {
+	rmSync(filepath, {
+		force: true,
+		recursive: true
+	});
+}
+function getProperty(target, prop) {
+	const member = target[prop];
+	if (typeof member === "function") return member.bind(target);
+	return member;
+}
+function getEggOptions() {
+	return {
+		baseDir: process.env.EGG_BASE_DIR ?? process.cwd(),
+		framework: process.env.EGG_FRAMEWORK
+	};
+}
+
+//#endregion
+export { getEggOptions, getProperty, getSourceDirname, rimraf, rimrafSync, sleep };

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 };