rspack-plugin-mock 1.0.1 → 1.2.0

package/dist/mockWebsocket-DkVHpZCx.d.cts

@@ -0,0 +1,85 @@
+import { LogLevel, MockOptions, MockServerPluginOptions, ServerBuildOption } from "./types-6lajtJPx.cjs";
+import { Server } from "node:http";
+import { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
+import { FSWatcher } from "node:fs";
+import EventEmitter from "node:events";
+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/mockCompiler.d.ts
+interface MockCompilerOptions {
+  alias?: Record<string, false | string | (string | false)[]>;
+  plugins: RspackPluginInstance[];
+  cwd?: string;
+  include: string | string[];
+  exclude: string | string[];
+  logger: Logger;
+}
+declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
+declare class MockCompiler extends EventEmitter {
+  options: MockCompilerOptions;
+  cwd: string;
+  mockWatcher: FSWatcher;
+  moduleType: "cjs" | "esm";
+  entryFile: string;
+  private _mockData;
+  private fileFilter;
+  private watchInfo?;
+  compiler?: Compiler | null;
+  constructor(options: MockCompilerOptions);
+  get mockData(): Record<string, MockOptions>;
+  run(): Promise<void>;
+  close(): void;
+  updateAlias(alias: Record<string, false | string | (string | false)[]>): void;
+  updateMockEntry(): Promise<void>;
+  getMockFiles(): Promise<string[]>;
+  watchMockFiles(): void;
+}
+//#endregion
+//#region src/core/resolvePluginOptions.d.ts
+interface ResolvedCompilerOptions {
+  alias: Record<string, false | string | (string | false)[]>;
+  proxies: (string | ((pathname: string, req: any) => boolean))[];
+  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+  plugins: RspackPluginInstance[];
+  context?: string;
+}
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, "build">> & ResolvedCompilerOptions & {
+  logger: Logger;
+  build: false | ServerBuildOption;
+};
+//#endregion
+//#region src/core/mockMiddleware.d.ts
+interface MiddlewareOptions {
+  alias: Record<string, false | string | (string | false)[]>;
+  proxies: (string | ((pathname: string, req: any) => boolean))[];
+  context?: string;
+  plugins: RspackPluginInstance[];
+}
+declare function createMockMiddleware(compiler: MockCompiler, options: ResolvePluginOptions): (middlewares: Middleware[], reload?: () => void) => Middleware[];
+type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized["devServer"]>["setupMiddlewares"]>;
+type Middleware = SetupMiddlewaresFn extends ((middlewares: (infer T)[], devServer: any) => void) ? T : never;
+type Server$1 = SetupMiddlewaresFn extends ((middlewares: any, devServer: infer T) => void) ? T : never;
+//#endregion
+//#region src/core/mockWebsocket.d.ts
+interface MockSocketOptions {
+  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+  cookiesOptions: MockServerPluginOptions["cookiesOptions"];
+  logger: Logger;
+}
+declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer, {
+  wsProxies: proxies,
+  cookiesOptions,
+  logger
+}: MockSocketOptions): void;
+//#endregion
+export { Logger, Middleware, MiddlewareOptions, MockCompiler, MockCompilerOptions, MockSocketOptions, ResolvePluginOptions, Server$1 as Server, createLogger, createMockCompiler, createMockMiddleware, logLevels, mockWebSocket };

package/dist/mockWebsocket-qLVAe-RI.d.ts

@@ -0,0 +1,85 @@
+import { LogLevel, MockOptions, MockServerPluginOptions, ServerBuildOption } from "./types-DPzh7nJq.js";
+import EventEmitter from "node:events";
+import { FSWatcher } from "node:fs";
+import { Compiler, RspackOptionsNormalized, RspackPluginInstance } from "@rspack/core";
+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/mockCompiler.d.ts
+interface MockCompilerOptions {
+  alias?: Record<string, false | string | (string | false)[]>;
+  plugins: RspackPluginInstance[];
+  cwd?: string;
+  include: string | string[];
+  exclude: string | string[];
+  logger: Logger;
+}
+declare function createMockCompiler(options: MockCompilerOptions): MockCompiler;
+declare class MockCompiler extends EventEmitter {
+  options: MockCompilerOptions;
+  cwd: string;
+  mockWatcher: FSWatcher;
+  moduleType: "cjs" | "esm";
+  entryFile: string;
+  private _mockData;
+  private fileFilter;
+  private watchInfo?;
+  compiler?: Compiler | null;
+  constructor(options: MockCompilerOptions);
+  get mockData(): Record<string, MockOptions>;
+  run(): Promise<void>;
+  close(): void;
+  updateAlias(alias: Record<string, false | string | (string | false)[]>): void;
+  updateMockEntry(): Promise<void>;
+  getMockFiles(): Promise<string[]>;
+  watchMockFiles(): void;
+}
+//#endregion
+//#region src/core/resolvePluginOptions.d.ts
+interface ResolvedCompilerOptions {
+  alias: Record<string, false | string | (string | false)[]>;
+  proxies: (string | ((pathname: string, req: any) => boolean))[];
+  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+  plugins: RspackPluginInstance[];
+  context?: string;
+}
+type ResolvePluginOptions = Required<Omit<MockServerPluginOptions, "build">> & ResolvedCompilerOptions & {
+  logger: Logger;
+  build: false | ServerBuildOption;
+};
+//#endregion
+//#region src/core/mockMiddleware.d.ts
+interface MiddlewareOptions {
+  alias: Record<string, false | string | (string | false)[]>;
+  proxies: (string | ((pathname: string, req: any) => boolean))[];
+  context?: string;
+  plugins: RspackPluginInstance[];
+}
+declare function createMockMiddleware(compiler: MockCompiler, options: ResolvePluginOptions): (middlewares: Middleware[], reload?: () => void) => Middleware[];
+type SetupMiddlewaresFn = NonNullable<NonNullable<RspackOptionsNormalized["devServer"]>["setupMiddlewares"]>;
+type Middleware = SetupMiddlewaresFn extends ((middlewares: (infer T)[], devServer: any) => void) ? T : never;
+type Server$1 = SetupMiddlewaresFn extends ((middlewares: any, devServer: infer T) => void) ? T : never;
+//#endregion
+//#region src/core/mockWebsocket.d.ts
+interface MockSocketOptions {
+  wsProxies: (string | ((pathname: string, req: any) => boolean))[];
+  cookiesOptions: MockServerPluginOptions["cookiesOptions"];
+  logger: Logger;
+}
+declare function mockWebSocket(compiler: MockCompiler, httpServer: Server | Http2SecureServer, {
+  wsProxies: proxies,
+  cookiesOptions,
+  logger
+}: MockSocketOptions): void;
+//#endregion
+export { Logger, Middleware, MiddlewareOptions, MockCompiler, MockCompilerOptions, MockSocketOptions, ResolvePluginOptions, Server$1 as Server, createLogger, createMockCompiler, createMockMiddleware, logLevels, mockWebSocket };

package/dist/resolvePluginOptions-Da5uqlBx.cjs

@@ -0,0 +1,506 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_logger = require('./logger-C0V8Cvvd.cjs');
+const __pengzhanbo_utils = require_chunk.__toESM(require("@pengzhanbo/utils"));
+const node_events = require_chunk.__toESM(require("node:events"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const node_process = require_chunk.__toESM(require("node:process"));
+const __rollup_pluginutils = require_chunk.__toESM(require("@rollup/pluginutils"));
+const chokidar = require_chunk.__toESM(require("chokidar"));
+const fast_glob = require_chunk.__toESM(require("fast-glob"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
+const picocolors = require_chunk.__toESM(require("picocolors"));
+const node_module = require_chunk.__toESM(require("node:module"));
+const __rspack_core = require_chunk.__toESM(require("@rspack/core"));
+const is_core_module = require_chunk.__toESM(require("is-core-module"));
+const node_url = require_chunk.__toESM(require("node:url"));
+const path_to_regexp = require_chunk.__toESM(require("path-to-regexp"));
+const cors = require_chunk.__toESM(require("cors"));
+
+//#region src/core/createRspackCompiler.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+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(picocolors.default.red(name), ...args);
+		};
+		if (err) {
+			logError(err.stack || err);
+			if ("details" in err) logError(err.details);
+			return;
+		}
+		if (stats?.hasErrors()) {
+			const info = stats.toJson();
+			logError(info.errors);
+		}
+		const code = require_logger.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: name$1 } of modules) if (name$1?.startsWith("external")) {
+				const packageName = normalizePackageName(name$1);
+				if (!(0, is_core_module.default)(packageName) && !aliasList.includes(packageName)) externals.push(normalizePackageName(name$1));
+			}
+		}
+		await callback({
+			code,
+			externals
+		});
+	}
+	const compiler = __rspack_core.rspack(rspackOptions, isWatch ? handler : void 0);
+	if (compiler) compiler.outputFileSystem = require_logger.vfs;
+	if (!isWatch) compiler?.run(async (...args) => {
+		await handler(...args);
+		compiler.close(() => {});
+	});
+	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 >= 18.0.0"];
+	if (alias && "@swc/helpers" in alias) delete alias["@swc/helpers"];
+	return {
+		mode: "production",
+		context: cwd,
+		entry: entryFile,
+		watch,
+		target: "node18.0",
+		externalsType: isEsm ? "module" : "commonjs2",
+		resolve: {
+			alias,
+			extensions: [
+				".js",
+				".ts",
+				".cjs",
+				".mjs",
+				".json5",
+				".json"
+			]
+		},
+		plugins,
+		output: {
+			library: { type: !isEsm ? "commonjs2" : "module" },
+			filename: "output.js",
+			path: "/"
+		},
+		experiments: { outputModule: isEsm },
+		optimization: { minimize: !watch },
+		module: { rules: [
+			{
+				test: /\.json5?$/,
+				loader: require$1.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/core/build.ts
+async function buildMockServer(options, outputDir) {
+	const entryFile = node_path.default.resolve(node_process.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	const mockFileList = await getMockFileList(options);
+	await writeMockEntryFile(entryFile, mockFileList, options.cwd);
+	const { code, externals } = await transformWithRspack({
+		entryFile,
+		cwd: options.cwd,
+		plugins: options.plugins,
+		alias: options.alias
+	});
+	await node_fs_promises.default.unlink(entryFile);
+	const outputList = [
+		{
+			filename: "mock-data.js",
+			source: code
+		},
+		{
+			filename: "index.js",
+			source: generatorServerEntryCode(options)
+		},
+		{
+			filename: "package.json",
+			source: generatePackageJson(options, externals)
+		}
+	];
+	const dist = node_path.default.resolve(outputDir, options.build.dist);
+	options.logger.info(`${picocolors.default.green("✓")} generate mock server in ${picocolors.default.cyan(node_path.default.relative(node_process.default.cwd(), dist))}`);
+	if (!node_fs.default.existsSync(dist)) await node_fs_promises.default.mkdir(dist, { recursive: true });
+	for (const { filename, source } of outputList) {
+		await node_fs_promises.default.writeFile(node_path.default.join(dist, filename), source, "utf8");
+		const sourceSize = (source.length / 1024).toFixed(2);
+		const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
+		options.logger.info(` ${picocolors.default.green(filename)}${space}${picocolors.default.bold(picocolors.default.dim(`${sourceSize} kB`))}`);
+	}
+}
+function generatePackageJson(options, externals) {
+	const deps = getHostDependencies(options.cwd);
+	const { name, version } = getPluginPackageInfo();
+	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);
+}
+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,
+  transformMockData,
+  transformRawData
+} 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((0, __pengzhanbo_utils.toArray)(wsPrefix))};
+const cookiesOptions = ${JSON.stringify(cookiesOptions)};
+const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
+const priority = ${JSON.stringify(priority)};
+const mockConfig = { 
+  mockData: transformMockData(transformRawData(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}');
+`;
+}
+async function getMockFileList({ cwd, include, exclude }) {
+	const filter = (0, __rollup_pluginutils.createFilter)(include, exclude, { resolve: false });
+	return await (0, fast_glob.default)(include, { cwd }).then((files) => files.filter(filter));
+}
+async function writeMockEntryFile(entryFile, files, cwd) {
+	const importers = [];
+	const exporters = [];
+	for (const [index, filepath] of files.entries()) {
+		const file = require_logger.normalizePath(node_path.default.join(cwd, filepath));
+		importers.push(`import * as m${index} from '${file}'`);
+		exporters.push(`[m${index}, '${filepath}']`);
+	}
+	const code = `${importers.join("\n")}\n\nexport default [\n  ${exporters.join(",\n  ")}\n]`;
+	const dirname = node_path.default.dirname(entryFile);
+	if (!node_fs.default.existsSync(dirname)) await node_fs_promises.default.mkdir(dirname, { recursive: true });
+	await node_fs_promises.default.writeFile(entryFile, code, "utf8");
+}
+function getPluginPackageInfo() {
+	let pkg = {};
+	try {
+		const filepath = node_path.default.join(require_logger.packageDir, "../package.json");
+		if (node_fs.default.existsSync(filepath)) pkg = JSON.parse(node_fs.default.readFileSync(filepath, "utf8"));
+	} catch {}
+	return {
+		name: pkg.name || "rspack-plugin-mock",
+		version: pkg.version || "latest"
+	};
+}
+function getHostDependencies(context) {
+	let pkg = {};
+	try {
+		const content = require_logger.lookupFile(context, ["package.json"]);
+		if (content) pkg = JSON.parse(content);
+	} catch {}
+	return {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+}
+
+//#endregion
+//#region src/core/loadFromCode.ts
+async function loadFromCode({ filepath, code, isESM, cwd }) {
+	filepath = node_path.default.resolve(cwd, filepath);
+	const ext = isESM ? ".mjs" : ".cjs";
+	const filepathTmp = `${filepath}.timestamp-${Date.now()}${ext}`;
+	const file = (0, node_url.pathToFileURL)(filepathTmp).toString();
+	await node_fs.promises.writeFile(filepathTmp, code, "utf8");
+	try {
+		const mod = await import(file);
+		return mod.default || mod;
+	} finally {
+		try {
+			node_fs.default.unlinkSync(filepathTmp);
+		} catch {}
+	}
+}
+
+//#endregion
+//#region src/core/mockCompiler.ts
+function createMockCompiler(options) {
+	return new MockCompiler(options);
+}
+var MockCompiler = class extends node_events.default {
+	cwd;
+	mockWatcher;
+	moduleType = "cjs";
+	entryFile;
+	_mockData = {};
+	fileFilter;
+	watchInfo;
+	compiler;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.cwd = options.cwd || node_process.default.cwd();
+		const { include, exclude } = this.options;
+		this.fileFilter = (0, __rollup_pluginutils.createFilter)(include, exclude, { resolve: false });
+		try {
+			const pkg = require_logger.lookupFile(this.cwd, ["package.json"]);
+			this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
+		} catch {}
+		this.entryFile = node_path.default.resolve(node_process.default.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
+	}
+	get mockData() {
+		return this._mockData;
+	}
+	async run() {
+		await this.updateMockEntry();
+		this.watchMockFiles();
+		const { plugins, alias } = this.options;
+		const options = {
+			isEsm: this.moduleType === "esm",
+			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.moduleType === "esm",
+					cwd: this.cwd
+				});
+				this._mockData = require_logger.transformMockData(require_logger.transformRawData(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() {
+		const files = await this.getMockFiles();
+		await writeMockEntryFile(this.entryFile, files, this.cwd);
+	}
+	async getMockFiles() {
+		const { include } = this.options;
+		const files = await (0, fast_glob.default)(include, { cwd: this.cwd });
+		return files.filter(this.fileFilter);
+	}
+	watchMockFiles() {
+		const { include } = this.options;
+		const [firstGlob, ...otherGlob] = (0, __pengzhanbo_utils.toArray)(include);
+		const watcher = this.mockWatcher = chokidar.default.watch(firstGlob, {
+			ignoreInitial: true,
+			cwd: this.cwd
+		});
+		if (otherGlob.length > 0) otherGlob.forEach((glob) => watcher.add(glob));
+		watcher.on("add", (filepath) => {
+			if (this.fileFilter(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "add"
+				};
+				this.updateMockEntry();
+			}
+		});
+		watcher.on("change", (filepath) => {
+			if (this.fileFilter(filepath)) this.watchInfo = {
+				filepath,
+				type: "change"
+			};
+		});
+		watcher.on("unlink", async (filepath) => {
+			this.watchInfo = {
+				filepath,
+				type: "unlink"
+			};
+			this.updateMockEntry();
+		});
+	}
+};
+
+//#endregion
+//#region src/core/mockMiddleware.ts
+function createMockMiddleware(compiler, options) {
+	return function mockMiddleware(middlewares, reload) {
+		middlewares.unshift(require_logger.baseMiddleware(compiler, options));
+		const corsMiddleware = createCorsMiddleware(compiler, options);
+		if (corsMiddleware) middlewares.unshift(corsMiddleware);
+		if (options.reload) compiler.on("update", () => reload?.());
+		return middlewares;
+	};
+}
+function createCorsMiddleware(compiler, options) {
+	let corsOptions = {};
+	const enabled = options.cors !== false;
+	if (enabled) corsOptions = {
+		...corsOptions,
+		...typeof options.cors === "boolean" ? {} : options.cors
+	};
+	const proxies = options.proxies;
+	return !enabled ? void 0 : function(req, res, next) {
+		const { pathname } = require_logger.urlParse(req.url);
+		if (!pathname || proxies.length === 0 || !proxies.some((context) => require_logger.doesProxyContextMatchUrl(context, req.url, req))) return next();
+		const mockData = compiler.mockData;
+		const mockUrl = Object.keys(mockData).find((key) => (0, path_to_regexp.pathToRegexp)(key).test(pathname));
+		if (!mockUrl) return next();
+		(0, cors.default)(corsOptions)(req, res, next);
+	};
+}
+
+//#endregion
+//#region src/core/resolvePluginOptions.ts
+function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"], exclude = [
+	"**/node_modules/**",
+	"**/.vscode/**",
+	"**/.git/**"
+], reload = false, log = "info", cors: cors$2 = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, { alias, context, plugins, proxies }) {
+	const logger = require_logger.createLogger("rspack:mock", (0, __pengzhanbo_utils.isBoolean)(log) ? log ? "info" : "error" : log);
+	prefix = (0, __pengzhanbo_utils.toArray)(prefix);
+	return {
+		prefix,
+		wsPrefix,
+		cwd: cwd || context || node_process.default.cwd(),
+		include,
+		exclude,
+		reload,
+		cors: cors$2,
+		cookiesOptions,
+		log,
+		formidableOptions: {
+			multiples: true,
+			...formidableOptions
+		},
+		bodyParserOptions,
+		priority,
+		build: build ? Object.assign({
+			serverPort: 8080,
+			dist: "mockServer",
+			log: "error"
+		}, typeof build === "object" ? build : {}) : false,
+		alias,
+		plugins,
+		proxies: [...proxies, ...prefix],
+		wsProxies: (0, __pengzhanbo_utils.toArray)(wsPrefix),
+		logger
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'MockCompiler', {
+  enumerable: true,
+  get: function () {
+    return MockCompiler;
+  }
+});
+Object.defineProperty(exports, 'buildMockServer', {
+  enumerable: true,
+  get: function () {
+    return buildMockServer;
+  }
+});
+Object.defineProperty(exports, 'createMockCompiler', {
+  enumerable: true,
+  get: function () {
+    return createMockCompiler;
+  }
+});
+Object.defineProperty(exports, 'createMockMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createMockMiddleware;
+  }
+});
+Object.defineProperty(exports, 'resolvePluginOptions', {
+  enumerable: true,
+  get: function () {
+    return resolvePluginOptions;
+  }
+});