rspack-plugin-mock 1.3.0 → 2.1.0

package/dist/options-CI0LRpJZ.js

@@ -0,0 +1,487 @@
+import { c as processRawData, d as normalizePath, f as vfs, h as createMatcher, m as getPackageDeps, p as getPackageDepList, s as processMockData, t as createLogger } from "./logger-CzeuHKAL.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { attemptAsync, isBoolean, isPlainObject, toArray, uniq } from "@pengzhanbo/utils";
+import * as rspackCore from "@rspack/core";
+import fs, { promises } from "node:fs";
+import fsp from "node:fs/promises";
+import ansis from "ansis";
+import { glob } from "tinyglobby";
+import isCore from "is-core-module";
+import { loadPackageJSONSync } from "local-pkg";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import EventEmitter from "node:events";
+import chokidar from "chokidar";
+//#region src/compiler/createRspackCompiler.ts
+const require = createRequire(import.meta.url);
+function createCompiler(options, callback) {
+	const rspackOptions = resolveRspackOptions(options);
+	const isWatch = rspackOptions.watch === true;
+	async function handler(err, stats) {
+		const name = "[rspack:mock]";
+		const logError = (...args) => {
+			if (stats) stats.compilation.getLogger(name).error(...args);
+			else console.error(ansis.red(name), ...args);
+		};
+		if (err) {
+			logError(err.stack || err);
+			if ("details" in err) logError(err.details);
+			return;
+		}
+		if (stats?.hasErrors()) logError(stats.toJson().errors);
+		const code = vfs.readFileSync("/output.js", "utf-8");
+		const externals = [];
+		if (!isWatch) {
+			const modules = stats?.toJson().modules || [];
+			const aliasList = Object.keys(options.alias || {}).map((key) => key.replace(/\$$/g, ""));
+			for (const { name } of modules) if (name?.startsWith("external")) {
+				const packageName = normalizePackageName(name);
+				if (!isCore(packageName) && !aliasList.includes(packageName)) externals.push(normalizePackageName(name));
+			}
+		}
+		await callback({
+			code,
+			externals
+		});
+	}
+	const compiler = rspackCore.rspack(rspackOptions);
+	compiler.outputFileSystem = vfs;
+	if (!isWatch) compiler.run(async (...args) => {
+		await handler(...args);
+		compiler.close(() => {});
+	});
+	else compiler.watch({}, handler);
+	return compiler;
+}
+function transformWithRspack(options) {
+	return new Promise((resolve) => {
+		createCompiler({
+			...options,
+			watch: false
+		}, (result) => {
+			resolve(result);
+		});
+	});
+}
+function normalizePackageName(name) {
+	const filepath = name.replace("external ", "").slice(1, -1);
+	const [scope, packageName] = filepath.split("/");
+	if (filepath[0] === "@") return `${scope}/${packageName}`;
+	return scope;
+}
+function resolveRspackOptions({ cwd, isEsm = true, entryFile, plugins, alias, watch = false }) {
+	const targets = ["node >= 20.0.0"];
+	if (alias && "@swc/helpers" in alias) delete alias["@swc/helpers"];
+	const externals = getPackageDepList(cwd);
+	const externalPattern = new RegExp(`^(${externals.join("|")})($|/)`, "i");
+	return {
+		mode: "production",
+		context: cwd,
+		entry: entryFile,
+		watch,
+		target: `node${(process.versions.node || "").replace(/\.\d+$/, "")}`,
+		externalsType: isEsm ? "module" : "commonjs2",
+		externals: [externalPattern],
+		resolve: {
+			alias,
+			extensions: [
+				".js",
+				".ts",
+				".cjs",
+				".mjs",
+				".json5",
+				".json"
+			]
+		},
+		plugins,
+		output: {
+			library: { type: !isEsm ? "commonjs2" : "module" },
+			filename: "output.js",
+			module: isEsm,
+			path: "/"
+		},
+		optimization: { minimize: !watch },
+		node: {
+			__dirname: false,
+			__filename: false
+		},
+		module: { rules: [
+			{
+				test: /\.json5?$/,
+				loader: require.resolve("#json5-loader"),
+				type: "javascript/auto"
+			},
+			{
+				test: /\.[cm]?js$/,
+				use: [{
+					loader: "builtin:swc-loader",
+					options: {
+						jsc: { parser: { syntax: "ecmascript" } },
+						env: { targets }
+					}
+				}]
+			},
+			{
+				test: /\.[cm]?ts$/,
+				use: [{
+					loader: "builtin:swc-loader",
+					options: {
+						jsc: { parser: { syntax: "typescript" } },
+						env: { targets }
+					}
+				}]
+			}
+		] }
+	};
+}
+//#endregion
+//#region src/compiler/loadFromCode.ts
+async function loadFromCode({ filepath, code, isESM, cwd }) {
+	filepath = path.resolve(cwd, filepath);
+	const ext = isESM ? ".mjs" : ".cjs";
+	const filepathTmp = `${filepath}.${getHash(code)}${ext}`;
+	await promises.writeFile(filepathTmp, code, "utf8");
+	const [, mod] = await attemptAsync(importDefault, String(pathToFileURL(filepathTmp)));
+	await attemptAsync(promises.unlink, filepathTmp);
+	return mod;
+}
+async function importDefault(filepath) {
+	const mod = await import(filepath);
+	return mod.default || mod;
+}
+function getHash(str) {
+	return createHash("md5").update(str).digest("hex");
+}
+//#endregion
+//#region src/compiler/mockCompiler.ts
+function createMockCompiler(options) {
+	return new MockCompiler(options);
+}
+var MockCompiler = class extends EventEmitter {
+	cwd;
+	mockWatcher;
+	entryFile;
+	deps = [];
+	isESM = false;
+	_mockData = {};
+	watchInfo;
+	compiler;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.cwd = options.cwd || process.cwd();
+		try {
+			const pkg = loadPackageJSONSync(this.cwd);
+			this.isESM = pkg?.type === "module";
+		} catch {}
+		this.entryFile = path.resolve(process.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	}
+	get mockData() {
+		return this._mockData;
+	}
+	async run() {
+		const { include, exclude } = this.options;
+		const { pattern, ignore, isMatch } = createMatcher(include, exclude);
+		const files = await glob(pattern, {
+			ignore,
+			cwd: path.join(this.cwd, this.options.dir)
+		});
+		this.deps = files.map((file) => normalizePath(file));
+		this.updateMockEntry();
+		this.watchMockFiles(isMatch);
+		const { plugins, alias } = this.options;
+		const options = {
+			isEsm: this.isESM,
+			cwd: this.cwd,
+			plugins,
+			entryFile: this.entryFile,
+			alias,
+			watch: true
+		};
+		this.compiler = createCompiler(options, async ({ code }) => {
+			try {
+				const result = await loadFromCode({
+					filepath: "mock.bundle.js",
+					code,
+					isESM: this.isESM,
+					cwd: this.cwd
+				});
+				this._mockData = processMockData(processRawData(result));
+				this.emit("update", this.watchInfo || {});
+			} catch (e) {
+				this.options.logger.error(e.stack || e.message);
+			}
+		});
+	}
+	close() {
+		this.mockWatcher.close();
+		this.compiler?.close(() => {});
+		this.emit("close");
+	}
+	updateAlias(alias) {
+		this.options.alias = {
+			...this.options.alias,
+			...alias
+		};
+	}
+	async updateMockEntry() {
+		await writeMockEntryFile(this.entryFile, this.deps, this.cwd, this.options.dir);
+	}
+	watchMockFiles(isMatch) {
+		const watcher = this.mockWatcher = chokidar.watch(this.options.dir, {
+			ignoreInitial: true,
+			cwd: this.cwd,
+			ignored: (filepath, stats) => {
+				if (filepath.includes("node_modules")) return true;
+				return !!stats?.isFile() && !isMatch(filepath);
+			}
+		});
+		watcher.on("add", (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "add"
+				};
+				this.deps = uniq([...this.deps, filepath]);
+				this.updateMockEntry();
+			}
+		});
+		watcher.on("change", (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) this.watchInfo = {
+				filepath,
+				type: "change"
+			};
+		});
+		watcher.on("unlink", async (filepath) => {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "unlink"
+				};
+				this.deps = this.deps.filter((dep) => dep !== filepath);
+				this.updateMockEntry();
+			}
+		});
+	}
+};
+//#endregion
+//#region package.json
+var name = "rspack-plugin-mock";
+var version = "2.1.0";
+//#endregion
+//#region src/build/packageJson.ts
+function generatePackageJson(options, externals) {
+	const deps = getPackageDeps(options.context);
+	const exclude = [
+		name,
+		"connect",
+		"cors"
+	];
+	const mockPkg = {
+		name: "mock-server",
+		type: "module",
+		scripts: { start: "node index.js" },
+		dependencies: {
+			connect: "^3.7.0",
+			[name]: `^${version}`,
+			cors: "^2.8.5"
+		}
+	};
+	externals.filter((dep) => !exclude.includes(dep)).forEach((dep) => {
+		mockPkg.dependencies[dep] = deps[dep] || "latest";
+	});
+	return JSON.stringify(mockPkg, null, 2);
+}
+//#endregion
+//#region src/build/serverEntryCode.ts
+function generatorServerEntryCode({ proxies, wsPrefix, cookiesOptions, bodyParserOptions, priority, build }) {
+	const { serverPort, log } = build;
+	return `import { createServer } from 'node:http';
+import connect from 'connect';
+import corsMiddleware from 'cors';
+import { 
+  baseMiddleware,
+  createLogger,
+  mockWebSocket,
+  processMockData,
+  processRawData
+} from 'rspack-plugin-mock/server';
+import rawData from './mock-data.js';
+
+const app = connect();
+const server = createServer(app);
+const logger = createLogger('mock-server', '${log}');
+const proxies = ${JSON.stringify(proxies)};
+const wsProxies = ${JSON.stringify(toArray(wsPrefix))};
+const cookiesOptions = ${JSON.stringify(cookiesOptions)};
+const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
+const priority = ${JSON.stringify(priority)};
+const mockConfig = { 
+  mockData: processMockData(processRawData(rawData)),
+  on: () => {},
+};
+
+mockWebSocket(mockConfig, server, { wsProxies, cookiesOptions, logger });
+
+app.use(corsMiddleware());
+app.use(baseMiddleware(mockConfig, {
+  formidableOptions: { multiples: true },
+  proxies,
+  priority,
+  cookiesOptions,
+  bodyParserOptions,
+  logger,
+}));
+
+server.listen(${serverPort});
+
+console.log('listen: http://localhost:${serverPort}');
+`;
+}
+//#endregion
+//#region src/build/writeEntryFile.ts
+async function writeMockEntryFile(entryFile, files, cwd, dir) {
+	const importers = [];
+	const exporters = [];
+	for (const [index, filepath] of files.entries()) {
+		const relative = normalizePath(path.join(dir, filepath));
+		const file = normalizePath(path.join(cwd, relative));
+		importers.push(`import * as m${index} from '${file}'`);
+		exporters.push(`[m${index}, '${relative}']`);
+	}
+	const code = `${importers.join("\n")}\n\nexport default [\n  ${exporters.join(",\n  ")}\n]`;
+	const dirname = path.dirname(entryFile);
+	if (!fs.existsSync(dirname)) await fsp.mkdir(dirname, { recursive: true });
+	await fsp.writeFile(entryFile, code, "utf8");
+}
+//#endregion
+//#region src/build/generate.ts
+async function buildMockServer(options, outputDir) {
+	const buildOptions = options.build;
+	const entryFile = path.resolve(process.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	const { pattern, ignore } = createMatcher(options.include, options.exclude);
+	await writeMockEntryFile(entryFile, await glob(pattern, {
+		ignore,
+		cwd: path.join(options.cwd, options.dir)
+	}), options.cwd, options.dir);
+	const { code, externals } = await transformWithRspack({
+		entryFile,
+		cwd: options.cwd,
+		plugins: options.plugins,
+		alias: options.alias
+	});
+	await fsp.unlink(entryFile);
+	const outputList = [
+		{
+			filename: "mock-data.js",
+			source: code
+		},
+		{
+			filename: "index.js",
+			source: generatorServerEntryCode(options)
+		},
+		{
+			filename: "package.json",
+			source: generatePackageJson(options, externals)
+		}
+	];
+	if (options.record.enabled && buildOptions.includeRecord) {
+		const files = await glob(path.join(options.record.dir, "**/*.json"), {
+			cwd: options.cwd,
+			dot: true
+		});
+		for (const file of files) outputList.push({
+			filename: path.join(outputDir, file),
+			source: await fsp.readFile(path.join(options.cwd, file), "utf-8")
+		});
+	}
+	const dist = path.resolve(outputDir, options.build.dist);
+	options.logger.info(`${ansis.green("✓")} generate mock server in ${ansis.cyan(path.relative(process.cwd(), dist))}`);
+	if (!fs.existsSync(dist)) await fsp.mkdir(dist, { recursive: true });
+	for (const { filename, source } of outputList) {
+		await fsp.writeFile(path.join(dist, filename), source, "utf8");
+		const sourceSize = (source.length / 1024).toFixed(2);
+		const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
+		options.logger.info(` ${ansis.green(filename)}${space}${ansis.bold.dim(`${sourceSize} kB`)}`);
+	}
+}
+//#endregion
+//#region src/core/options.ts
+function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, dir = "mock", include = ["**/*.mock.{js,ts,cjs,mjs,json,json5}"], exclude = [], reload = false, log = "info", cors = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {}, activeScene = [], record = false, replay }, { alias, context, plugins, proxies: rawProxies }) {
+	const logger = createLogger("rspack:mock", isBoolean(log) ? log ? "info" : "error" : log);
+	const proxies = [...toArray(prefix), ...rawProxies];
+	const wsProxies = toArray(wsPrefix);
+	if (!proxies.length && !wsProxies.length) logger.warn(`No proxy was configured, mock server will not work. See ${ansis.cyan("https://vite-plugin-mock-dev-server.netlify.app/guide/usage")}`);
+	const enabled = !!cors;
+	let corsOptions = {};
+	if (enabled && isPlainObject(cors)) corsOptions = {
+		...corsOptions,
+		...cors
+	};
+	cwd = cwd || context || process.cwd();
+	const resolvedRecord = resolveRecordOptions(cwd, dir, record);
+	return {
+		enabled: true,
+		prefix,
+		wsPrefix,
+		cwd,
+		dir,
+		include,
+		exclude,
+		reload,
+		cors: enabled ? corsOptions : false,
+		cookiesOptions,
+		log,
+		formidableOptions: {
+			multiples: true,
+			...formidableOptions
+		},
+		bodyParserOptions,
+		priority,
+		build: build ? {
+			serverPort: 8080,
+			dist: "mockServer",
+			log: "error",
+			...typeof build === "object" ? build : {}
+		} : false,
+		alias,
+		plugins,
+		proxies,
+		wsProxies,
+		logger,
+		activeScene: toArray(activeScene),
+		record: resolvedRecord,
+		replay: replay ?? resolvedRecord.enabled ?? false
+	};
+}
+/**
+* Resolve record options
+*
+* 解析录制配置
+*
+* @param cwd - Current working directory / 当前工作目录
+* @param dir - Mock context directory / 模拟上下文目录
+* @param record - Record options / 录制配置
+* @returns Resolved record options / 解析后的录制配置
+*/
+function resolveRecordOptions(cwd, dir, record) {
+	const recordOptions = typeof record === "boolean" ? { enabled: record } : record;
+	const expires = recordOptions?.expires ?? 0;
+	return {
+		enabled: recordOptions?.enabled ?? false,
+		cwd,
+		dir: path.join(dir, recordOptions?.dir || ".recordings"),
+		overwrite: recordOptions?.overwrite ?? true,
+		status: toArray(recordOptions?.status).map(Number),
+		expires: expires === 0 ? Number.MAX_SAFE_INTEGER : expires * 1e3,
+		gitignore: recordOptions?.gitignore ?? true,
+		filter: recordOptions?.filter || (() => true)
+	};
+}
+//#endregion
+export { buildMockServer as n, createMockCompiler as r, resolvePluginOptions as t };

package/dist/rsbuild.d.ts

@@ -0,0 +1,8 @@
+import { A as ResponseBody, C as HandleFunction, D as MockResponse, E as MockRequest, M as CookiesOption, N as GetCookieOption, O as NextFunction, P as SetCookieOption, S as ExtraRequest, T as Method, _ as RecordedMeta, a as MockWebsocketItem, b as RecordedRes, c as MockHttpItem, d as LogType, f as MockMatchPriority, g as RecordOptions, h as ServerBuildOption, i as MockOptions, j as SimpleHandleFunction, k as NextHandleFunction, l as BodyParserOptions, m as MockServerPluginOptions, n as HttpProxyPlugin, o as WebSocketSetupContext, p as MockMatchSpecialPriority, r as PathFilter, s as MockErrorConfig, t as FormidableFile, u as LogLevel, v as RecordedReq, w as Headers, x as ResolvedRecordOptions, y as RecordedRequest } from "./index-BMMGM-eD.js";
+import { DefineMockDataOptions, HeaderStream, MockData, SSEMessage, createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper.js";
+import { RsbuildPlugin } from "@rsbuild/core";
+
+//#region src/core/rsbuild.d.ts
+declare function pluginMockServer(options?: MockServerPluginOptions): RsbuildPlugin;
+//#endregion
+export { BodyParserOptions, CookiesOption, DefineMockDataOptions, ExtraRequest, type FormidableFile, GetCookieOption, HandleFunction, HeaderStream, Headers, HttpProxyPlugin, LogLevel, LogType, Method, MockData, MockErrorConfig, type MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, type MockOptions, type MockRequest, MockResponse, type MockServerPluginOptions, type MockWebsocketItem, NextFunction, NextHandleFunction, PathFilter, RecordOptions, RecordedMeta, RecordedReq, RecordedRequest, RecordedRes, ResolvedRecordOptions, ResponseBody, SSEMessage, ServerBuildOption, SetCookieOption, SimpleHandleFunction, WebSocketSetupContext, createDefineMock, createSSEStream, defineMock, defineMockData, pluginMockServer };

package/dist/rsbuild.js

@@ -0,0 +1,80 @@
+import { a as rewriteRequest, i as createMockMiddleware, o as Recorder, r as mockWebSocket } from "./logger-CzeuHKAL.js";
+import { n as buildMockServer, r as createMockCompiler, t as resolvePluginOptions } from "./options-CI0LRpJZ.js";
+import { createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper.js";
+import path from "node:path";
+import process from "node:process";
+import { isArray, objectEntries, toArray } from "@pengzhanbo/utils";
+import rspack from "@rspack/core";
+//#region src/core/rsbuild.ts
+function pluginMockServer(options = {}) {
+	return {
+		name: "plugin-mock-server",
+		setup(api) {
+			if (options.enabled === false) return;
+			const rsbuildConfig = api.getRsbuildConfig();
+			const resolvedOptions = resolvePluginOptions(options, {
+				proxies: resolveConfigProxies(rsbuildConfig),
+				alias: {},
+				context: api.context.rootPath,
+				plugins: [new rspack.DefinePlugin(rsbuildConfig.source?.define || {})]
+			});
+			if (api.context.action === "build") {
+				if (resolvedOptions.build) api.onAfterBuild(async () => {
+					const config = api.getNormalizedConfig();
+					await buildMockServer(resolvedOptions, path.resolve(process.cwd(), config.output.distPath.root || "dist"));
+				});
+				return;
+			}
+			const mockCompiler = createMockCompiler(resolvedOptions);
+			api.onAfterCreateCompiler(({ compiler }) => {
+				if ("compilers" in compiler) compiler.compilers.forEach((compiler) => {
+					mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
+				});
+				else mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
+			});
+			let recorder = null;
+			if (resolvedOptions.record.enabled) recorder = new Recorder(resolvedOptions.record);
+			function wrapProxyOptions(options) {
+				const plugins = options.plugins ??= [];
+				plugins.push((proxyServer) => proxyServer.on("proxyReq", rewriteRequest));
+				if (resolvedOptions.record.enabled && recorder) plugins.push(recorder.getPlugin());
+				return options;
+			}
+			api.modifyRsbuildConfig((config) => {
+				if (!config.server?.proxy) return;
+				if (isArray(config.server.proxy)) config.server.proxy = config.server.proxy.map((item) => item.ws ? item : wrapProxyOptions(item));
+				else if (config.server.proxy) {
+					const proxy = config.server.proxy;
+					Object.keys(proxy).forEach((key) => {
+						const target = proxy[key];
+						const options = typeof target === "string" ? { target } : target;
+						if (options.ws) return;
+						proxy[key] = wrapProxyOptions(options);
+					});
+				}
+			});
+			function initMockServer(server) {
+				server.middlewares.use(createMockMiddleware(mockCompiler, resolvedOptions));
+				if (resolvedOptions.reload && api.context.action === "dev") mockCompiler.on("update", () => server.sockWrite("static-changed"));
+				if (toArray(resolvedOptions.wsPrefix).length > 0) mockWebSocket(mockCompiler, server.httpServer, resolvedOptions);
+				mockCompiler.run();
+			}
+			api.onBeforeStartDevServer(({ server }) => initMockServer(server));
+			api.onBeforeStartPreviewServer(({ server }) => initMockServer(server));
+			api.onExit(() => mockCompiler.close());
+		}
+	};
+}
+function resolveConfigProxies(config) {
+	config.server ??= {};
+	const proxy = config.server.proxy ??= {};
+	const proxies = [];
+	if (isArray(proxy)) {
+		for (const item of proxy) if (item.pathFilter && !item.ws) proxies.push(...toArray(item.pathFilter));
+	} else objectEntries(proxy).forEach(([pathFilter, opt]) => {
+		if (typeof opt === "string" || !opt.ws) proxies.push(pathFilter);
+	});
+	return proxies;
+}
+//#endregion
+export { createDefineMock, createSSEStream, defineMock, defineMockData, pluginMockServer };

package/dist/server-pC78IYdH.d.ts

@@ -0,0 +1,113 @@
+import { a as MockWebsocketItem, c as MockHttpItem, h as ServerBuildOption, i as MockOptions, k as NextHandleFunction, m as MockServerPluginOptions, r as PathFilter, u as LogLevel, x as ResolvedRecordOptions } from "./index-BMMGM-eD.js";
+import { Arrayable } from "@pengzhanbo/utils";
+import { Compiler, RspackPluginInstance } from "@rspack/core";
+import { Matcher } from "picomatch";
+import EventEmitter from "node:events";
+import { FSWatcher } from "chokidar";
+import { CorsOptions } from "cors";
+import { Server } from "node:http";
+import { Http2SecureServer } from "node:http2";
+
+//#region src/core/logger.d.ts
+interface Logger {
+  debug: (msg: string, level?: boolean | LogLevel) => void;
+  info: (msg: string, level?: boolean | LogLevel) => void;
+  warn: (msg: string, level?: boolean | LogLevel) => void;
+  error: (msg: string, level?: boolean | LogLevel) => void;
+}
+declare const logLevels: Record<LogLevel, number>;
+declare function createLogger(prefix: string, defaultLevel?: LogLevel): Logger;
+//#endregion
+//#region src/core/options.d.ts
+interface ResolvedCompilerOptions {
+  alias: Record<string, Arrayable<false | string>>;
+  proxies: PathFilter[];
+  wsProxies: PathFilter[];
+  plugins: RspackPluginInstance[];
+  context?: string;
+}
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, "build">> & ResolvedCompilerOptions & {
+  logger: Logger;
+  build: false | ServerBuildOption;
+  cors: false | CorsOptions;
+  record: ResolvedRecordOptions;
+  activeScene: string[];
+};
+//#endregion
+//#region src/compiler/mockCompiler.d.ts
+declare class MockCompiler extends EventEmitter {
+  options: ResolvePluginOptions;
+  cwd: string;
+  mockWatcher!: FSWatcher;
+  entryFile!: string;
+  deps: string[];
+  isESM: boolean;
+  private _mockData;
+  private watchInfo?;
+  compiler?: Compiler | null;
+  constructor(options: ResolvePluginOptions);
+  get mockData(): Record<string, MockOptions>;
+  run(): Promise<void>;
+  close(): void;
+  updateAlias(alias: Record<string, false | string | (string | false)[]>): void;
+  updateMockEntry(): Promise<void>;
+  watchMockFiles(isMatch: Matcher): void;
+}
+//#endregion
+//#region src/compiler/processData.d.ts
+declare function processRawData(rawData: (readonly [any, string])[]): (MockHttpItem | MockWebsocketItem | MockOptions)[];
+declare function processMockData(mockList: (MockHttpItem | MockWebsocketItem | MockOptions)[]): Record<string, MockOptions>;
+declare function sortByValidator(mocks: MockOptions): (MockHttpItem | MockWebsocketItem)[];
+//#endregion
+//#region src/mockHttp/middleware.d.ts
+interface CreateMockMiddlewareOptions extends Pick<ResolvePluginOptions, "formidableOptions" | "cookiesOptions" | "bodyParserOptions" | "priority" | "record" | "replay" | "activeScene"> {
+  proxies: PathFilter[];
+  logger: Logger;
+  cors: false | CorsOptions;
+}
+/**
+* Create mock middleware
+*
+* 创建 Mock 中间件
+*
+* @param compiler - Compiler instance / 编译器实例
+* @param options - Middleware options / 中间件配置项
+* @param options.formidableOptions - Formidable options / Formidable 配置项
+* @param options.bodyParserOptions - Body parser options / 请求体解析配置项
+* @param options.proxies - Proxy paths / 代理路径
+* @param options.cookiesOptions - Cookies options / Cookies 配置项
+* @param options.logger - Logger instance / 日志实例
+* @param options.priority - Path matching priority / 路径匹配优先级
+* @param options.cors - CORS options / CORS 配置项
+* @param options.record - Record options / 录制配置项
+* @param options.replay - Replay options / 回放配置项
+* @param options.activeScene - Active scene / 活动场景
+*
+* @returns Connect middleware function / Connect 中间件函数
+*/
+declare function createMockMiddleware(compiler: MockCompiler, {
+  formidableOptions,
+  bodyParserOptions,
+  proxies,
+  cookiesOptions,
+  logger,
+  priority,
+  cors: corsOptions,
+  record,
+  replay,
+  activeScene
+}: CreateMockMiddlewareOptions): NextHandleFunction;
+//#endregion
+//#region src/mockWebsocket/server.d.ts
+interface MockSocketOptions {
+  wsProxies: PathFilter[];
+  cookiesOptions: MockServerPluginOptions["cookiesOptions"];
+  logger: Logger;
+}
+declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer | null, {
+  wsProxies: proxies,
+  cookiesOptions,
+  logger
+}: MockSocketOptions): void;
+//#endregion
+export { processMockData as a, MockCompiler as c, createLogger as d, logLevels as f, createMockMiddleware as i, ResolvePluginOptions as l, mockWebSocket as n, processRawData as o, CreateMockMiddlewareOptions as r, sortByValidator as s, MockSocketOptions as t, Logger as u };

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { a as processMockData, d as createLogger, f as logLevels, i as createMockMiddleware, n as mockWebSocket, o as processRawData, r as CreateMockMiddlewareOptions, s as sortByValidator, t as MockSocketOptions, u as Logger } from "./server-pC78IYdH.js";
+export { CreateMockMiddlewareOptions, Logger, MockSocketOptions, createLogger, createMockMiddleware, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };

package/dist/server.js

@@ -0,0 +1,2 @@
+import { c as processRawData, i as createMockMiddleware, l as sortByValidator, n as logLevels, r as mockWebSocket, s as processMockData, t as createLogger } from "./logger-CzeuHKAL.js";
+export { createLogger, createMockMiddleware, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };