rspack-plugin-mock 2.0.0 → 2.2.0

package/dist/{ws-BcLCWVaK.js → logger-DTZcb53u.js}

@@ -1,24 +1,24 @@
-import { attemptAsync, isArray, isBoolean, isEmptyObject, isFunction, isPlainObject, isString, objectKeys, partition, random, sleep, sortBy, timestamp, toArray, uniq } from "@pengzhanbo/utils";
 import path from "node:path";
+import { attempt, attemptAsync, deepEqual, hasOwn, isArray, isBoolean, isEmptyObject, isFunction, isPlainObject, isString, kebabCase, objectKeys, omit, partition, random, sleep, sortBy, timestamp, toArray, uniq } from "@pengzhanbo/utils";
+import fs, { promises } from "node:fs";
 import ansis from "ansis";
 import picomatch from "picomatch";
 import { loadPackageJSONSync } from "local-pkg";
 import { match, parse, pathToRegexp } from "path-to-regexp";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
-import Debug from "debug";
 import { Volume, createFsFromVolume } from "memfs";
 import { parse as parse$1 } from "node:querystring";
-import crypto from "node:crypto";
 import cors from "cors";
 import bodyParser from "co-body";
 import formidable from "formidable";
-import http from "node:http";
+import Cookies from "cookies";
 import { Buffer } from "node:buffer";
+import zlib from "node:zlib";
 import HTTP_STATUS from "http-status";
 import * as mime from "mime-types";
 import { WebSocketServer } from "ws";
-//#region src/utils/createMatcher.ts
+
 function createMatcher(include, exclude, defaultIgnore = true) {
 	const pattern = [];
 	const ignore = [...defaultIgnore ? ["**/node_modules/**"] : [], ...toArray(exclude)];
@@ -32,12 +32,12 @@ function createMatcher(include, exclude, defaultIgnore = true) {
 		isMatch: picomatch(pattern, { ignore })
 	};
 }
-//#endregion
-//#region src/utils/doesProxyContextMatchUrl.ts
-const PATTERN_CACHE = /* @__PURE__ */ new Map();
+
+
+const PATTERN_CACHE =  new Map();
 function doesProxyContextMatchUrl(context, req) {
 	const url = req.url;
-	if (typeof context === "function") return context(url, req);
+	if (typeof context === "function") return !!context(url, req);
 	if (context[0] === "^") {
 		let pattern = PATTERN_CACHE.get(context);
 		if (!pattern) PATTERN_CACHE.set(context, pattern = new RegExp(context));
@@ -45,8 +45,8 @@ function doesProxyContextMatchUrl(context, req) {
 	}
 	return url.startsWith(context);
 }
-//#endregion
-//#region src/utils/getDeps.ts
+
+
 function getPackageDeps(cwd) {
 	const { dependencies, devDependencies, peerDependencies, optionalDependencies } = loadPackageJSONSync(cwd) || {};
 	return {
@@ -57,25 +57,28 @@ function getPackageDeps(cwd) {
 	};
 }
 function getPackageDepList(cwd) {
-	return uniq(objectKeys(getPackageDeps(cwd)));
+	const deps = getPackageDeps(cwd);
+	return uniq(objectKeys(deps));
 }
-//#endregion
-//#region src/utils/is.ts
+
+
 function isStream(stream) {
 	return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
 }
 function isReadableStream(stream) {
 	return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
 }
-//#endregion
-//#region src/utils/isObjectSubset.ts
-/**
-* Checks if target object is a subset of source object.
-* That is, all properties and their corresponding values in target exist in source.
-*
-* 深度比较两个对象之间，target 是否属于 source 的子集，
-* 即 target 的所有属性和对应的值，都在 source 中，
-*/
+
+function isTextContent(contentType) {
+	return [
+		"text",
+		"json",
+		"xml"
+	].some((type) => contentType.includes(type));
+}
+
+
+
 function isObjectSubset(source, target) {
 	if (!target) return true;
 	for (const key in target) if (!isIncluded(source[key], target[key])) return false;
@@ -83,7 +86,7 @@ function isObjectSubset(source, target) {
 }
 function isIncluded(source, target) {
 	if (isArray(source) && isArray(target)) {
-		const seen = /* @__PURE__ */ new Set();
+		const seen =  new Set();
 		return target.every((ti) => source.some((si, i) => {
 			if (seen.has(i)) return false;
 			const included = isIncluded(si, ti);
@@ -94,12 +97,10 @@ function isIncluded(source, target) {
 	if (isPlainObject(source) && isPlainObject(target)) return isObjectSubset(source, target);
 	return Object.is(source, target);
 }
-//#endregion
-//#region src/utils/isPathMatch.ts
-const cache = /* @__PURE__ */ new Map();
-/**
-* 判断 path 是否匹配 pattern
-*/
+
+
+const cache =  new Map();
+
 function isPathMatch(pattern, path) {
 	let regexp = cache.get(pattern);
 	if (!regexp) {
@@ -108,47 +109,20 @@ function isPathMatch(pattern, path) {
 	}
 	return regexp.test(path);
 }
-//#endregion
-//#region src/utils/logger.ts
-const logLevels = {
-	silent: 0,
-	error: 1,
-	warn: 2,
-	info: 3,
-	debug: 4
-};
-function createLogger(prefix, defaultLevel = "info") {
-	prefix = `[${prefix}]`;
-	function output(type, msg, level) {
-		level = isBoolean(level) ? level ? defaultLevel : "error" : level;
-		if (logLevels[level] >= logLevels[type]) {
-			const method = type === "info" || type === "debug" ? "log" : type;
-			const tag = type === "debug" ? ansis.magenta.bold(prefix) : type === "info" ? ansis.cyan.bold(prefix) : type === "warn" ? ansis.yellow.bold(prefix) : ansis.red.bold(prefix);
-			const format = `${ansis.dim((/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
-			console[method](format);
-		}
-	}
-	return {
-		debug(msg, level = defaultLevel) {
-			output("debug", msg, level);
-		},
-		info(msg, level = defaultLevel) {
-			output("info", msg, level);
-		},
-		warn(msg, level = defaultLevel) {
-			output("warn", msg, level);
-		},
-		error(msg, level = defaultLevel) {
-			output("error", msg, level);
-		}
-	};
+
+
+function matchScene(activeScene, mockScene) {
+	if (!mockScene) return true;
+	const scenes = toArray(mockScene);
+	if (activeScene.length === 0 && scenes.length > 0) return false;
+	if (scenes.length === 0) return true;
+	return scenes.some((s) => activeScene.includes(s));
 }
 getDirname(import.meta.url);
 const vfs = createFsFromVolume(new Volume());
 function getDirname(importMetaUrl) {
 	return path.dirname(fileURLToPath(importMetaUrl));
 }
-Debug("vite:mock-dev-server");
 const windowsSlashRE = /\\/g;
 const isWindows = os.platform() === "win32";
 function slash(p) {
@@ -157,12 +131,9 @@ function slash(p) {
 function normalizePath(id) {
 	return path.posix.normalize(isWindows ? slash(id) : id);
 }
-//#endregion
-//#region src/utils/urlParse.ts
-/**
-* nodejs 从 19.0.0 开始 弃用 url.parse，因此使用 url.parse 来解析 可能会报错，
-* 使用 URL 来解析
-*/
+
+
+
 function urlParse(input) {
 	const url = new URL(input, "http://example.com");
 	return {
@@ -170,29 +141,21 @@ function urlParse(input) {
 		query: parse$1(url.search.replace(/^\?/, ""))
 	};
 }
-//#endregion
-//#region src/utils/waitingFor.ts
-function waitingFor(onSuccess, maxRetry = 5) {
-	return function wait(getter, retry = 0) {
-		const value = getter();
-		if (value) onSuccess(value);
-		else if (retry < maxRetry) setTimeout(() => wait(getter, retry + 1), 100);
-	};
-}
-//#endregion
-//#region src/compiler/processData.ts
+
+
 function processRawData(rawData) {
 	return rawData.filter((item) => item[0]).map(([raw, __filepath__]) => {
 		let mockConfig;
-		if (raw.default) if (isArray(raw.default)) mockConfig = raw.default.map((item) => ({
-			...item,
-			__filepath__
-		}));
-		else mockConfig = {
-			...raw.default,
-			__filepath__
-		};
-		else if ("url" in raw) mockConfig = {
+		if (raw.default) {
+			if (isArray(raw.default)) mockConfig = raw.default.map((item) => ({
+				...item,
+				__filepath__
+			}));
+			else mockConfig = {
+				...raw.default,
+				__filepath__
+			};
+		} else if ("url" in raw) mockConfig = {
 			...raw,
 			__filepath__
 		};
@@ -226,16 +189,18 @@ function processMockData(mockList) {
 		};
 		if (current.ws !== true) {
 			const validator = current.validator;
-			if (!isEmptyObject(query)) if (isFunction(validator)) current.validator = function(request) {
-				return isObjectSubset(request.query, query) && validator(request);
-			};
-			else if (validator) {
-				current.validator = { ...validator };
-				current.validator.query = current.validator.query ? {
-					...query,
-					...current.validator.query
-				} : query;
-			} else current.validator = { query };
+			if (!isEmptyObject(query)) {
+				if (isFunction(validator)) current.validator = function(request) {
+					return isObjectSubset(request.query, query) && validator(request);
+				};
+				else if (validator) {
+					current.validator = { ...validator };
+					current.validator.query = current.validator.query ? {
+						...query,
+						...current.validator.query
+					} : query;
+				} else current.validator = { query };
+			}
 		}
 		list.push(current);
 	});
@@ -257,28 +222,19 @@ function keysCount(obj) {
 	if (!obj) return 0;
 	return objectKeys(obj).length;
 }
-//#endregion
-//#region src/core/cors.ts
-/**
-* Create CORS middleware
-*
-* 创建 CORS 中间件
-*
-* @param corsOptions - CORS options / CORS 配置项
-* @returns CORS middleware function or undefined / CORS 中间件函数或未定义
-*/
+
+
+
 function createCors(corsOptions) {
 	const corsMiddleware = corsOptions ? cors(corsOptions) : void 0;
 	return corsMiddleware ? (req, res) => new Promise((resolve, reject) => corsMiddleware(req, res, (err) => {
 		err ? reject(err) : resolve();
 	})) : void 0;
 }
-//#endregion
-//#region src/core/request.ts
-/**
-* 解析请求体 request.body
-*/
-async function parseRequestBody(req, formidableOptions, bodyParserOptions = {}) {
+
+
+
+async function parseRequestBody(req, logger, formidableOptions, bodyParserOptions = {}) {
 	const method = req.method.toUpperCase();
 	if (["HEAD", "OPTIONS"].includes(method)) return void 0;
 	const type = req.headers["content-type"]?.toLocaleLowerCase() || "";
@@ -298,18 +254,17 @@ async function parseRequestBody(req, formidableOptions, bodyParserOptions = {})
 		});
 		if (type.startsWith("multipart/form-data")) return await parseRequestBodyWithMultipart(req, formidableOptions);
 	} catch (e) {
-		console.error(e);
+		logger.error(e);
 	}
 }
+
 const DEFAULT_FORMIDABLE_OPTIONS = {
 	keepExtensions: true,
 	filename(name, ext, part) {
 		return part?.originalFilename || `${name}.${Date.now()}${ext ? `.${ext}` : ""}`;
 	}
 };
-/**
-* 解析 request form multipart body
-*/
+
 async function parseRequestBodyWithMultipart(req, options) {
 	const form = formidable({
 		...DEFAULT_FORMIDABLE_OPTIONS,
@@ -328,10 +283,9 @@ async function parseRequestBodyWithMultipart(req, options) {
 		});
 	});
 }
-const matcherCache = /* @__PURE__ */ new Map();
-/**
-* 解析请求 url 中的动态参数 params
-*/
+
+const matcherCache =  new Map();
+
 function parseRequestParams(pattern, url) {
 	let matcher = matcherCache.get(pattern);
 	if (!matcher) {
@@ -341,16 +295,16 @@ function parseRequestParams(pattern, url) {
 	const matched = matcher(url);
 	return matched ? matched.params : {};
 }
-/**
-* 验证请求是否符合 validator
-*/
+
 function requestValidate(request, validator) {
 	return isObjectSubset(request.headers, validator.headers) && isObjectSubset(request.body, validator.body) && isObjectSubset(request.params, validator.params) && isObjectSubset(request.query, validator.query) && isObjectSubset(request.refererQuery, validator.refererQuery);
 }
+
 function formatLog(prefix, data) {
 	return !data || isEmptyObject(data) ? "" : `  ${ansis.gray(`${prefix}:`)}${JSON.stringify(data)}`;
 }
-function requestLog(request, filepath) {
+
+function requestLog(request, filepath, shouldSimulateError) {
 	const { url, method, query, params, body } = request;
 	let { pathname } = new URL(url, "http://example.com");
 	pathname = ansis.green(decodeURIComponent(pathname));
@@ -358,18 +312,18 @@ function requestLog(request, filepath) {
 	const qs = formatLog("query", query);
 	const ps = formatLog("params", params);
 	const bs = formatLog("body", body);
+	const es = shouldSimulateError ? ` 🎲 ${ansis.bgYellow("ERR")}` : "";
 	const file = `  ${ansis.dim.underline(`(${filepath})`)}`;
-	return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
-}
-//#endregion
-//#region src/core/findMockData.ts
-/**
-* 查找匹配的 mock data
-*/
-function findMockData(mockList, logger, { pathname, method, request }) {
+	return `${ms}${es} ${pathname}${qs}${ps}${bs}${file}`;
+}
+
+
+
+function findMockData(mockList, logger, { pathname, method, request, activeScene }) {
 	return mockList.find((mock) => {
 		if (!pathname || !mock || !mock.url || mock.ws) return false;
 		if (!(mock.method ? isArray(mock.method) ? mock.method : [mock.method] : ["GET", "POST"]).includes(method)) return false;
+		if (!matchScene(activeScene, mock.scene)) return false;
 		const hasMock = isPathMatch(mock.url, pathname);
 		if (hasMock && mock.validator) {
 			const params = parseRequestParams(mock.url, pathname);
@@ -377,226 +331,345 @@ function findMockData(mockList, logger, { pathname, method, request }) {
 				params,
 				...request
 			});
-			else try {
-				return requestValidate({
+			else {
+				const [error, validated] = attempt(requestValidate, {
 					params,
 					...request
 				}, mock.validator);
-			} catch (e) {
-				const file = mock.__filepath__;
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at validator (${ansis.underline(file)})`, mock.log);
-				return false;
+				if (error) {
+					const file = mock.__filepath__;
+					logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${error}\n  at validator (${ansis.underline(file)})`, mock.log);
+					return false;
+				}
+				return validated;
 			}
 		}
 		return hasMock;
 	});
 }
-//#endregion
-//#region src/cookies/constants.ts
-/**
-* RegExp to match field-content in RFC 7230 sec 3.2
-*
-* field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
-* field-vchar   = VCHAR / obs-text
-* obs-text      = %x80-FF
-*/
-const fieldContentRegExp = /^[\t\u0020-\u007E\u0080-\u00FF]+$/;
-/**
-* RegExp to match Priority cookie attribute value.
-*/
-const PRIORITY_REGEXP = /^(?:low|medium|high)$/i;
-/**
-* Cache for generated name regular expressions.
-*/
-const REGEXP_CACHE = Object.create(null);
-/**
-* RegExp to match all characters to escape in a RegExp.
-*/
-const REGEXP_ESCAPE_CHARS_REGEXP = /[\^$\\.*+?()[\]{}|]/g;
-/**
-* RegExp to match basic restricted name characters for loose validation.
-*/
-const RESTRICTED_NAME_CHARS_REGEXP = /[;=]/;
-/**
-* RegExp to match basic restricted value characters for loose validation.
-*/
-const RESTRICTED_VALUE_CHARS_REGEXP = /;/;
-/**
-* RegExp to match Same-Site cookie attribute value.
-*/
-const SAME_SITE_REGEXP = /^(?:lax|none|strict)$/i;
-//#endregion
-//#region src/cookies/Cookie.ts
-var Cookie = class {
-	name;
-	value;
-	maxAge;
-	expires;
-	path = "/";
-	domain;
-	secure = false;
-	httpOnly = true;
-	sameSite = false;
-	overwrite = false;
-	priority;
-	partitioned;
-	constructor(name, value, options = {}) {
-		if (!fieldContentRegExp.test(name) || RESTRICTED_NAME_CHARS_REGEXP.test(name)) throw new TypeError("argument name is invalid");
-		if (value && (!fieldContentRegExp.test(value) || RESTRICTED_VALUE_CHARS_REGEXP.test(value))) throw new TypeError("argument value is invalid");
-		this.name = name;
-		this.value = value;
-		Object.assign(this, options);
-		if (!this.value) {
-			this.expires = /* @__PURE__ */ new Date(0);
-			this.maxAge = void 0;
+
+
+const FILTERED_RESPONSE_HEADERS = [
+	"date",
+	"expires",
+	"last-modified",
+	"server",
+	"x-powered-by",
+	"x-aspnet-version",
+	"x-nginx-version",
+	"via",
+	"cache-control",
+	"etag",
+	"age",
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"proxy-connection",
+	"trailer",
+	"access-control-allow-origin",
+	"access-control-allow-credentials",
+	"access-control-allow-methods",
+	"access-control-allow-headers",
+	"access-control-expose-headers",
+	"access-control-max-age",
+	"origin",
+	"p3p",
+	"pragma",
+	"x-request-id",
+	"x-correlation-id",
+	"x-trace-id",
+	"x-varnish",
+	"x-cache",
+	"x-cache-hits",
+	"x-cache-status",
+	"cf-cache-status",
+	"cf-ray",
+	"cf-request-id",
+	"server-timing",
+	"x-dns-prefetch-control"
+];
+
+
+
+async function decompressBody(rawBody, encoding) {
+	try {
+		switch (encoding.toLowerCase()) {
+			case "gzip":
+			case "x-gzip": return {
+				body: await gunzip(rawBody),
+				encoding: "identity"
+			};
+			case "deflate":
+			case "x-deflate": return {
+				body: await deflate(rawBody),
+				encoding: "identity"
+			};
+			case "br": return {
+				body: await brotli(rawBody),
+				encoding: "identity"
+			};
+			case "zstd": return {
+				body: await zstd(rawBody),
+				encoding: "identity"
+			};
 		}
-		if (this.path && !fieldContentRegExp.test(this.path)) throw new TypeError("[Cookie] option path is invalid");
-		if (this.domain && !fieldContentRegExp.test(this.domain)) throw new TypeError("[Cookie] option domain is invalid");
-		if (typeof this.maxAge === "number" ? Number.isNaN(this.maxAge) || !Number.isFinite(this.maxAge) : this.maxAge) throw new TypeError("[Cookie] option maxAge is invalid");
-		if (this.priority && !PRIORITY_REGEXP.test(this.priority)) throw new TypeError("[Cookie] option priority is invalid");
-		if (this.sameSite && this.sameSite !== true && !SAME_SITE_REGEXP.test(this.sameSite)) throw new TypeError("[Cookie] option sameSite is invalid");
+	} catch {}
+	return {
+		body: rawBody,
+		encoding
+	};
+}
+let zstdStreaming = null;
+
+async function zstd(rawBody) {
+	if (zlib.zstdDecompress) return new Promise((resolve, reject) => {
+		zlib.zstdDecompress(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+	if (!zstdStreaming) {
+		const { ZstdCodec } = await import("zstd-codec");
+		zstdStreaming = await new Promise((resolve) => {
+			ZstdCodec.run((binding) => {
+				resolve(new binding.Streaming());
+			});
+		});
+	}
+	return zstdStreaming.decompress(rawBody, rawBody.length);
+}
+
+async function brotli(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.brotliDecompress(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+async function gunzip(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.gunzip(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+async function deflate(rawBody) {
+	return new Promise((resolve, reject) => {
+		zlib.inflate(rawBody, (err, data) => {
+			err ? reject(err) : resolve(data);
+		});
+	});
+}
+
+
+const timeFormatter = new Intl.DateTimeFormat("en-US", {
+	year: "numeric",
+	month: "numeric",
+	day: "numeric",
+	hour: "numeric",
+	minute: "numeric",
+	second: "numeric",
+	hour12: false
+});
+
+function processRecordReq(req, pathname, body) {
+	const { query } = urlParse(req.url);
+	const method = req.method.toUpperCase();
+	let bodyType = (req.headers["content-type"] || "").split(";")[0].trim();
+	if (bodyType.startsWith("multipart/form-data") && isPlainObject(body)) {
+		body = { ...body };
+		objectKeys(body).forEach((key) => {
+			const value = body[key];
+			if (isPlainObject(value) && hasOwn(value, "filepath") && hasOwn(value, "mimetype")) delete body[key];
+		});
 	}
-	toString() {
-		return `${this.name}=${this.value}`;
+	if (Buffer.isBuffer(body)) {
+		body = body.toString();
+		bodyType = "buffer";
 	}
-	toHeader() {
-		let header = this.toString();
-		if (this.maxAge) this.expires = new Date(Date.now() + this.maxAge);
-		if (this.path) header += `; path=${this.path}`;
-		if (this.expires) header += `; expires=${this.expires.toUTCString()}`;
-		if (this.domain) header += `; domain=${this.domain}`;
-		if (this.priority) header += `; priority=${this.priority.toLowerCase()}`;
-		if (this.sameSite) header += `; samesite=${this.sameSite === true ? "strict" : this.sameSite.toLowerCase()}`;
-		if (this.secure) header += "; secure";
-		if (this.httpOnly) header += "; httponly";
-		if (this.partitioned) header += "; partitioned";
-		return header;
+	return {
+		method,
+		pathname,
+		query,
+		bodyType,
+		body
+	};
+}
+
+async function processRecordRes(res, body) {
+	const status = res.statusCode || 200;
+	const statusText = res.statusMessage || "OK";
+	const headers = {};
+	for (const [key, value] of Object.entries(res.headers)) {
+		const lowerKey = key.toLowerCase();
+		if (value !== void 0 && !FILTERED_RESPONSE_HEADERS.includes(lowerKey)) headers[key] = String(value);
 	}
-};
-//#endregion
-//#region src/cookies/timeSafeCompare.ts
-function bufferEqual(a, b) {
-	if (a.length !== b.length) return false;
-	if (crypto.timingSafeEqual) return crypto.timingSafeEqual(a, b);
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	const isText = isTextContent(headers["content-type"] || "");
+	if (isText) {
+		const { body: decodedBody, encoding } = await decompressBody(body, headers["content-encoding"] || "");
+		body = Buffer.from(decodedBody);
+		headers["content-encoding"] = encoding;
+	}
+	return {
+		status,
+		statusText,
+		headers,
+		body: body.toString(isText ? "utf-8" : "base64")
+	};
+}
+
+function isSameRecord(prev, current) {
+	if (prev.pathname !== current.pathname || prev.method !== current.method) return false;
+	if (prev.bodyType !== current.bodyType) return false;
+	if (!deepEqual(prev.query, current.query)) return false;
+	if (current.bodyType === "buffer" && prev.bodyType === "buffer") {
+		const currentBody = Buffer.from(current.body);
+		const prevBody = Buffer.from(prev.body);
+		if (currentBody.length !== prevBody.length || !currentBody.equals(prevBody)) return false;
+	}
+	if (!deepEqual(prev.body, current.body)) return false;
 	return true;
 }
-function createHmac(key, data) {
-	return crypto.createHmac("sha256", key).update(data).digest();
-}
-function timeSafeCompare(a, b) {
-	const sa = String(a);
-	const sb = String(b);
-	const key = crypto.randomBytes(32);
-	return bufferEqual(createHmac(key, sa), createHmac(key, sb)) && a === b;
-}
-//#endregion
-//#region src/cookies/Keygrip.ts
-const SLASH_PATTERN = /[/+=]/g;
-const REPLACE_MAP = {
-	"/": "_",
-	"+": "-",
-	"=": ""
-};
-var Keygrip = class {
-	algorithm;
-	encoding;
-	keys = [];
-	constructor(keys, algorithm, encoding) {
-		this.keys = keys;
-		this.algorithm = algorithm || "sha256";
-		this.encoding = encoding || "base64";
+
+function createRecordMatcher(filter) {
+	if (isFunction(filter)) return filter;
+	const { mode = "glob" } = filter;
+	const include = toArray(filter.include);
+	const exclude = toArray(filter.exclude);
+	if (mode === "glob") {
+		const { isMatch } = createMatcher(include, exclude);
+		return (req) => isMatch(req.pathname);
 	}
-	sign(data, key = this.keys[0]) {
-		return crypto.createHmac(this.algorithm, key).update(data).digest(this.encoding).replace(SLASH_PATTERN, (m) => REPLACE_MAP[m]);
+	return (req) => {
+		return include.some((pattern) => isPathMatch(pattern, req.pathname)) && exclude.every((pattern) => !isPathMatch(pattern, req.pathname));
+	};
+}
+
+function getFilepath(pathname, dir) {
+	return path.join(dir, `${kebabCase(pathname)}.json`);
+}
+
+
+const storage =  new Map();
+
+async function readRecordStorage(filepath) {
+	if (storage.has(filepath)) return storage.get(filepath);
+	try {
+		if (!fs.existsSync(filepath)) return [];
+		const content = await fs.promises.readFile(filepath, "utf-8") || "[]";
+		const data = JSON.parse(content);
+		storage.set(filepath, data);
+		return data;
+	} catch (error) {
+		console.error(`Error reading record file ${filepath}:`, error);
+		return [];
 	}
-	index(data, digest) {
-		for (let i = 0, l = this.keys.length; i < l; i++) if (timeSafeCompare(digest, this.sign(data, this.keys[i]))) return i;
-		return -1;
+}
+
+async function writeRecordStorage(filepath, records) {
+	try {
+		storage.set(filepath, records);
+		await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
+		await fs.promises.writeFile(filepath, JSON.stringify(records, null, 2), "utf-8");
+	} catch (error) {
+		console.error(`Error writing record file ${filepath}:`, error);
 	}
-	verify(data, digest) {
-		return this.index(data, digest) > -1;
+}
+const originalReqCache =  new WeakMap();
+
+function recordRequestWithRawReq(req, pathname, body) {
+	originalReqCache.set(req, {
+		body,
+		pathname,
+		timestamp: Date.now()
+	});
+}
+
+
+
+var Recorder = class {
+	options;
+	filter;
+	constructor(options) {
+		this.options = options;
+		this.filter = createRecordMatcher(options.filter);
+		this.addGitignore();
 	}
-};
-//#endregion
-//#region src/cookies/Cookies.ts
-var Cookies = class {
-	request;
-	response;
-	secure;
-	keys;
-	constructor(req, res, options = {}) {
-		this.request = req;
-		this.response = res;
-		this.secure = options.secure;
-		if (options.keys instanceof Keygrip) this.keys = options.keys;
-		else if (isArray(options.keys)) this.keys = new Keygrip(options.keys);
+	getPlugin() {
+		return (proxyServer) => {
+			proxyServer.on("proxyRes", (proxyRes, req) => {
+				let chunks = [];
+				proxyRes.on("data", (chunk) => chunk && chunks.push(chunk));
+				proxyRes.on("end", () => {
+					this.record(req, proxyRes, Buffer.concat(chunks));
+					chunks = null;
+				});
+			});
+		};
 	}
-	set(name, value, options) {
-		const req = this.request;
-		const res = this.response;
-		const headers = toArray(res.getHeader("Set-Cookie"));
-		const cookie = new Cookie(name, value, options);
-		const signed = options?.signed ?? !!this.keys;
-		const secure = this.secure === void 0 ? req.protocol === "https" || isRequestEncrypted(req) : Boolean(this.secure);
-		if (!secure && options?.secure) throw new Error("Cannot send secure cookie over unencrypted connection");
-		cookie.secure = options?.secure ?? secure;
-		pushCookie(headers, cookie);
-		if (signed && options) {
-			if (!this.keys) throw new Error(".keys required for signed cookies");
-			cookie.value = this.keys.sign(cookie.toString());
-			cookie.name += ".sig";
-			pushCookie(headers, cookie);
-		}
-		(res.set ? http.OutgoingMessage.prototype.setHeader : res.setHeader).call(res, "Set-Cookie", headers);
-		return this;
+	async record(req, res, resBody) {
+		if (!originalReqCache.has(req)) return;
+		const { body, pathname, timestamp } = originalReqCache.get(req);
+		originalReqCache.delete(req);
+		if (!pathname) return;
+		const recordReq = processRecordReq(req, pathname, body);
+		if (!this.filter(recordReq)) return;
+		const { cwd, dir, status, expires, overwrite } = this.options;
+		if (status.length !== 0 && !status.includes(res.statusCode || 200)) return;
+		const record = {
+			meta: {
+				timestamp,
+				filepath: "",
+				createAt: timeFormatter.format(timestamp),
+				referer: req.headers.referer || "unknown"
+			},
+			req: recordReq,
+			res: await processRecordRes(res, resBody)
+		};
+		const filepath = getFilepath(pathname, dir);
+		record.meta.filepath = filepath;
+		const absoluteFilepath = path.join(cwd, filepath);
+		const records = (await readRecordStorage(absoluteFilepath)).filter((item) => timestamp - item.meta.timestamp <= expires);
+		const index = records.findIndex((item) => isSameRecord(item.req, record.req) && item.res.status === record.res.status);
+		if (index === -1) records.push(record);
+		else if (overwrite || timestamp - records[index].meta.timestamp > expires) records[index] = record;
+		await writeRecordStorage(absoluteFilepath, records);
 	}
-	get(name, options) {
-		const signName = `${name}.sig`;
-		const signed = options?.signed ?? !!this.keys;
-		const header = this.request.headers.cookie;
-		if (!header) return;
-		const match = header.match(getPattern(name));
-		if (!match) return;
-		let value = match[1];
-		if (value[0] === "\"") value = value.slice(1, -1);
-		if (!options || !signed) return value;
-		const remote = this.get(signName);
-		if (!remote) return;
-		const data = `${name}=${value}`;
-		if (!this.keys) throw new Error(".keys required for signed cookies");
-		const index = this.keys.index(data, remote);
-		if (index < 0) this.set(signName, null, {
-			path: "/",
-			signed: false
-		});
-		else {
-			index && this.set(signName, this.keys.sign(data), { signed: false });
-			return value;
-		}
+	async addGitignore() {
+		const options = this.options;
+		if (!options.gitignore) return;
+		const dirname = path.join(options.cwd, options.dir);
+		await promises.mkdir(dirname, { recursive: true });
+		if (!fs.existsSync(path.join(dirname, ".gitignore"))) await promises.writeFile(path.join(dirname, ".gitignore"), "*\n", "utf-8");
 	}
 };
-/**
-* Get the pattern to search for a cookie in a string.
-*/
-function getPattern(name) {
-	if (!REGEXP_CACHE[name]) REGEXP_CACHE[name] = new RegExp(`(?:^|;) *${name.replace(REGEXP_ESCAPE_CHARS_REGEXP, "\\$&")}=([^;]*)`);
-	return REGEXP_CACHE[name];
-}
-/**
-* Get the encrypted status for a request.
-*/
-function isRequestEncrypted(req) {
-	return Boolean(req.socket ? req.socket.encrypted : req.connection.encrypted);
-}
-function pushCookie(headers, cookie) {
-	if (cookie.overwrite) {
-		for (let i = headers.length - 1; i >= 0; i--) if (headers[i].indexOf(`${cookie.name}=`) === 0) headers.splice(i, 1);
+
+
+
+async function replayRecordedRequest(rawReq, pathname, body, options) {
+	const req = processRecordReq(rawReq, pathname, body);
+	const filepath = path.join(options.cwd, getFilepath(req.pathname, options.dir));
+	const timestamp = Date.now();
+	const records = await readRecordStorage(filepath);
+	const matchedList = records.filter((item) => timestamp - item.meta.timestamp < options.expires && isSameRecord(item.req, req));
+	let matched;
+	if (options.status.length === 0) matched = matchedList.find((item) => item.res.status === 200) || records[0];
+	else matched = matchedList.find((item) => options.status.includes(item.res.status));
+	if (matched) {
+		const isText = isTextContent(matched.res.headers["content-type"] || "");
+		return {
+			url: matched.req.pathname,
+			status: matched.res.status,
+			statusText: matched.res.statusText,
+			headers: matched.res.headers,
+			body: Buffer.from(matched.res.body, isText ? "utf-8" : "base64"),
+			type: "buffer",
+			__filepath__: matched.meta.filepath
+		};
 	}
-	headers.push(cookie.toHeader());
 }
-//#endregion
-//#region src/core/matchingWeight.ts
+
+
 const tokensCache = {};
 function getTokens(rule) {
 	if (tokensCache[rule]) return tokensCache[rule];
@@ -648,16 +721,7 @@ function defaultPriority(rules) {
 	const highest = getHighest(rules);
 	return rules.sort((a, b) => computedWeight(a, highest) - computedWeight(b, highest));
 }
-/**
-* Calculate matching weight for mock URLs
-*
-* 计算 Mock URL 的匹配权重
-*
-* @param rules - Array of URL patterns / URL 模式数组
-* @param url - Request URL / 请求 URL
-* @param priority - Priority configuration / 优先级配置
-* @returns Sorted array of matched rules / 排序后的匹配规则数组
-*/
+
 function matchingWeight(rules, url, priority) {
 	let matched = defaultPriority(rules.filter((rule) => isPathMatch(rule, url)));
 	const { global = [], special = {} } = priority;
@@ -682,22 +746,16 @@ function matchingWeight(rules, url, priority) {
 	}
 	return matched;
 }
-//#endregion
-//#region src/core/requestRecovery.ts
-/**
-* 请求复原
-*
-* 由于 parseReqBody 在解析请求时，会将请求流消费，
-* 导致当接口不需要被 mock，继而由 vite http-proxy 转发时，请求流无法继续。
-* 为此，我们在请求流中记录请求数据，当当前请求无法继续时，可以从备份中恢复请求流
-*/
-const requestCollectCache = /* @__PURE__ */ new WeakMap();
+
+
+
+const requestCollectCache =  new WeakMap();
 function collectRequest(req) {
 	const chunks = [];
-	req.addListener("data", (chunk) => {
+	req.on("data", (chunk) => {
 		chunks.push(Buffer.from(chunk));
 	});
-	req.addListener("end", () => {
+	req.on("end", () => {
 		if (chunks.length) requestCollectCache.set(req, Buffer.concat(chunks));
 	});
 }
@@ -709,24 +767,18 @@ function rewriteRequest(proxyReq, req) {
 		if (!proxyReq.writableEnded) proxyReq.write(buffer);
 	}
 }
-//#endregion
-//#region src/core/response.ts
-/**
-* 根据状态码获取状态文本
-*/
+
+
+
 function getHTTPStatusText(status) {
 	return HTTP_STATUS[status] || "Unknown";
 }
-/**
-* 设置响应状态
-*/
+
 function provideResponseStatus(response, status = 200, statusText) {
 	response.statusCode = status;
 	response.statusMessage = statusText || getHTTPStatusText(status);
 }
-/**
-* 设置响应头
-*/
+
 async function provideResponseHeaders(req, res, mock, logger) {
 	const { headers, type = "json" } = mock;
 	const filepath = mock.__filepath__;
@@ -736,38 +788,30 @@ async function provideResponseHeaders(req, res, mock, logger) {
 	res.setHeader("X-Mock-Power-By", "vite-plugin-mock-dev-server");
 	if (filepath) res.setHeader("X-File-Path", filepath);
 	if (!headers) return;
-	try {
-		const raw = isFunction(headers) ? await headers(req) : headers;
-		Object.keys(raw).forEach((key) => {
-			res.setHeader(key, raw[key]);
-		});
-	} catch (e) {
-		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at headers (${ansis.underline(filepath)})`, mock.log);
+	const [error, data] = await attemptAsync(async () => isFunction(headers) ? await headers(req) : headers);
+	if (error) {
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${error}\n  at headers (${ansis.underline(filepath)})`, mock.log);
+		return;
 	}
+	objectKeys(data).forEach((key) => res.setHeader(key, data[key]));
 }
-/**
-* 设置响应cookie
-*/
+
 async function provideResponseCookies(req, res, mock, logger) {
 	const { cookies } = mock;
-	const filepath = mock.__filepath__;
 	if (!cookies) return;
-	try {
-		const raw = isFunction(cookies) ? await cookies(req) : cookies;
-		Object.keys(raw).forEach((key) => {
-			const cookie = raw[key];
-			if (isArray(cookie)) {
-				const [value, options] = cookie;
-				res.setCookie(key, value, options);
-			} else res.setCookie(key, cookie);
-		});
-	} catch (e) {
-		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at cookies (${ansis.underline(filepath)})`, mock.log);
+	const [error, data] = await attemptAsync(async () => isFunction(cookies) ? await cookies(req) : cookies);
+	if (error) {
+		const filepath = mock.__filepath__;
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${error}\n  at cookies (${ansis.underline(filepath)})`, mock.log);
+		return;
 	}
+	objectKeys(data).forEach((key) => {
+		const cookie = data[key];
+		const [value, options] = isArray(cookie) ? cookie : [cookie];
+		res.setCookie(key, value, options);
+	});
 }
-/**
-* 设置响应数据
-*/
+
 function sendResponseData(res, raw, type) {
 	if (isReadableStream(raw)) raw.pipe(res);
 	else if (Buffer.isBuffer(raw)) res.end(type === "text" || type === "json" ? raw.toString("utf-8") : raw);
@@ -776,9 +820,7 @@ function sendResponseData(res, raw, type) {
 		res.end(type === "buffer" ? Buffer.from(content) : content);
 	}
 }
-/**
-* 实际响应延迟
-*/
+
 async function responseRealDelay(startTime, delay) {
 	if (!delay || typeof delay === "number" && delay <= 0 || isArray(delay) && delay.length !== 2) return;
 	let realDelay = 0;
@@ -788,9 +830,10 @@ async function responseRealDelay(startTime, delay) {
 	} else realDelay = delay - (timestamp() - startTime);
 	if (realDelay > 0) await sleep(realDelay);
 }
-//#endregion
-//#region src/core/mockMiddleware.ts
-function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions = {}, proxies, cookiesOptions, logger, priority = {}, cors: corsOptions }) {
+
+
+
+function createMockMiddleware(compiler, { formidableOptions = {}, bodyParserOptions = {}, proxies, cookiesOptions, logger, priority = {}, cors: corsOptions, record, replay, activeScene }) {
 	const cors = createCors(corsOptions);
 	const [globFilter, contextFilter] = partition(proxies, (item) => isString(item) && item.includes("*"));
 	const { isMatch: isGlobProxiesMatch } = createMatcher(globFilter, [], false);
@@ -802,35 +845,38 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 		if (globFilter.length && !isGlobProxiesMatch(pathname)) return next();
 		const mockData = compiler.mockData;
 		const mockUrls = matchingWeight(Object.keys(mockData), pathname, priority);
-		if (mockUrls.length === 0) return next();
+		if (mockUrls.length === 0 && !record.enabled) return next();
 		collectRequest(req);
-		const { query: refererQuery } = urlParse(req.headers.referer || "");
-		const reqBody = await parseRequestBody(req, formidableOptions, bodyParserOptions);
 		const cookies = new Cookies(req, res, cookiesOptions);
-		const getCookie = cookies.get.bind(cookies);
-		const method = req.method.toUpperCase();
 		let mock;
 		let _mockUrl;
+		const method = req.method.toUpperCase();
+		const extraReq = {
+			query,
+			refererQuery: urlParse(req.headers.referer || "").query,
+			body: await parseRequestBody(req, logger, formidableOptions, bodyParserOptions),
+			headers: req.headers,
+			getCookie: cookies.get.bind(cookies)
+		};
+		const headerScene = req.headers["x-mock-scene"];
+		const effectiveScene = headerScene ? toArray(headerScene).map((item) => item.split(",").map((s) => s.trim())).flat().filter(Boolean) : activeScene;
 		for (const mockUrl of mockUrls) {
 			mock = findMockData(mockData[mockUrl], logger, {
 				pathname,
 				method,
-				request: {
-					query,
-					refererQuery,
-					body: reqBody,
-					headers: req.headers,
-					getCookie
-				}
+				request: extraReq,
+				activeScene: effectiveScene
 			});
 			if (mock) {
 				_mockUrl = mockUrl;
 				break;
 			}
 		}
+		if (replay && !mock) mock = await replayRecordedRequest(req, pathname, extraReq.body, record);
 		if (!mock) {
+			record.enabled && recordRequestWithRawReq(req, pathname, extraReq.body);
 			const matched = mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ");
-			logger.warn(`${ansis.green(pathname)} matches  ${matched} , but mock data is not found.`);
+			matched.length && logger.warn(`${ansis.green(pathname)} matches ${matched}, but mock data is not found.`);
 			return next();
 		}
 		if (cors) {
@@ -842,36 +888,42 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 		}
 		const request = req;
 		const response = res;
-		request.body = reqBody;
-		request.query = query;
-		request.refererQuery = refererQuery;
+		Object.assign(request, omit(extraReq, ["headers"]));
 		request.params = parseRequestParams(mock.url, pathname);
-		request.getCookie = getCookie;
 		response.setCookie = cookies.set.bind(cookies);
-		const { body, delay, type = "json", response: responseFn, status = 200, statusText, log: logLevel, __filepath__: filepath } = mock;
+		const { delay, type = "json", response: responseFn, log: logLevel, error: errorConfig, __filepath__: filepath } = mock;
+		let { body, status = 200, statusText } = mock;
+		const shouldSimulateError = errorConfig && (errorConfig.probability ?? .5) > Math.random();
+		if (shouldSimulateError) {
+			status = errorConfig.status ?? 500;
+			statusText = errorConfig.statusText;
+			body = errorConfig.body;
+		}
 		provideResponseStatus(response, status, statusText);
 		await provideResponseHeaders(request, response, mock, logger);
 		await provideResponseCookies(request, response, mock, logger);
-		logger.info(requestLog(request, filepath), logLevel);
-		logger.debug(`${ansis.magenta("DEBUG")} ${ansis.underline(pathname)}  matches: [ ${mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ")} ]\n`);
+		logger.info(requestLog(request, filepath, shouldSimulateError), logLevel);
+		logger.debug(`${ansis.magenta("DEBUG")} ${ansis.underline(pathname)} matches: [ ${mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ")} ]\n`);
 		if (body) {
-			try {
+			const [error] = await attemptAsync(async () => {
 				const content = isFunction(body) ? await body(request) : body;
 				await responseRealDelay(startTime, delay);
 				sendResponseData(response, content, type);
-			} catch (e) {
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at body (${ansis.underline(filepath)})`, logLevel);
+			});
+			if (error) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n  ${error}\n  at body (${ansis.underline.gray(filepath)})`, logLevel);
 				provideResponseStatus(response, 500);
 				res.end("");
 			}
 			return;
 		}
 		if (responseFn) {
-			try {
+			const [error] = await attemptAsync(async () => {
 				await responseRealDelay(startTime, delay);
 				await responseFn(request, response, next);
-			} catch (e) {
-				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at response (${ansis.underline(filepath)})`, logLevel);
+			});
+			if (error) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n  ${error}\n  at response (${ansis.underline.gray(filepath)})`, logLevel);
 				provideResponseStatus(response, 500);
 				res.end("");
 			}
@@ -880,20 +932,20 @@ function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions =
 		res.end("");
 	};
 }
-//#endregion
-//#region src/core/ws.ts
+
+
 function mockWebSocket(compiler, httpServer, { wsProxies: proxies, cookiesOptions, logger }) {
-	const hmrMap = /* @__PURE__ */ new Map();
-	const poolMap = /* @__PURE__ */ new Map();
-	const wssContextMap = /* @__PURE__ */ new WeakMap();
+	const hmrMap =  new Map();
+	const poolMap =  new Map();
+	const wssContextMap =  new WeakMap();
 	const getWssMap = (mockUrl) => {
 		let wssMap = poolMap.get(mockUrl);
-		if (!wssMap) poolMap.set(mockUrl, wssMap = /* @__PURE__ */ new Map());
+		if (!wssMap) poolMap.set(mockUrl, wssMap =  new Map());
 		return wssMap;
 	};
 	const addHmr = (filepath, mockUrl) => {
 		let urlList = hmrMap.get(filepath);
-		if (!urlList) hmrMap.set(filepath, urlList = /* @__PURE__ */ new Set());
+		if (!urlList) hmrMap.set(filepath, urlList =  new Set());
 		urlList.add(mockUrl);
 	};
 	const setupWss = (wssMap, wss, mock, context, pathname, filepath) => {
@@ -999,5 +1051,40 @@ function cleanupRunner(cleanupList) {
 	let cleanup;
 	while (cleanup = cleanupList.shift()) cleanup?.();
 }
-//#endregion
-export { processRawData as a, normalizePath as c, logLevels as d, getPackageDepList as f, processMockData as i, vfs as l, createMatcher as m, baseMiddleware as n, sortByValidator as o, getPackageDeps as p, rewriteRequest as r, waitingFor as s, mockWebSocket as t, createLogger as u };
+
+
+const logLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+function createLogger(prefix, defaultLevel = "info") {
+	prefix = `[${prefix}]`;
+	function output(type, msg, level) {
+		level = isBoolean(level) ? level ? defaultLevel : "error" : level;
+		if (logLevels[level] >= logLevels[type]) {
+			const method = type === "info" || type === "debug" ? "log" : type;
+			const tag = type === "debug" ? ansis.magenta.bold(prefix) : type === "info" ? ansis.cyan.bold(prefix) : type === "warn" ? ansis.yellow.bold(prefix) : ansis.red.bold(prefix);
+			const format = `${ansis.dim(( new Date()).toLocaleTimeString())} ${tag} ${msg}`;
+			console[method](format);
+		}
+	}
+	return {
+		debug(msg, level = defaultLevel) {
+			output("debug", msg, level);
+		},
+		info(msg, level = defaultLevel) {
+			output("info", msg, level);
+		},
+		warn(msg, level = defaultLevel) {
+			output("warn", msg, level);
+		},
+		error(msg, level = defaultLevel) {
+			output("error", msg, level);
+		}
+	};
+}
+
+export { rewriteRequest as a, processRawData as c, vfs as d, getPackageDepList as f, createMockMiddleware as i, sortByValidator as l, createMatcher as m, logLevels as n, Recorder as o, getPackageDeps as p, mockWebSocket as r, processMockData as s, createLogger as t, normalizePath as u };