rspack-plugin-mock 1.2.0 → 2.0.0

package/dist/{resolvePluginOptions-DlkIkykz.js → options-Bd0PSZeT.js}

@@ -1,22 +1,20 @@
-import { baseMiddleware, createLogger, doesProxyContextMatchUrl, lookupFile, normalizePath, packageDir, transformMockData, transformRawData, urlParse, vfs } from "./logger-C48_LmdS.js";
+import { a as processRawData, c as normalizePath, f as getPackageDepList, i as processMockData, l as vfs, m as createMatcher, p as getPackageDeps, u as createLogger } from "./ws-BcLCWVaK.js";
 import { createRequire } from "node:module";
-import { isBoolean, toArray } from "@pengzhanbo/utils";
-import EventEmitter from "node:events";
+import { attemptAsync, isBoolean, isPlainObject, toArray, uniq } from "@pengzhanbo/utils";
 import path from "node:path";
 import process from "node:process";
-import { createFilter } from "@rollup/pluginutils";
-import chokidar from "chokidar";
-import fastGlob from "fast-glob";
+import * as rspackCore from "@rspack/core";
 import fs, { promises } from "node:fs";
 import fsp from "node:fs/promises";
-import color from "picocolors";
-import * as rspackCore from "@rspack/core";
+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 { pathToRegexp } from "path-to-regexp";
-import cors from "cors";
-
-//#region src/core/createRspackCompiler.ts
+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);
@@ -25,25 +23,22 @@ function createCompiler(options, callback) {
 		const name = "[rspack:mock]";
 		const logError = (...args) => {
 			if (stats) stats.compilation.getLogger(name).error(...args);
-			else console.error(color.red(name), ...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()) {
-			const info = stats.toJson();
-			logError(info.errors);
-		}
+		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: name$1 } of modules) if (name$1?.startsWith("external")) {
-				const packageName = normalizePackageName(name$1);
-				if (!isCore(packageName) && !aliasList.includes(packageName)) externals.push(normalizePackageName(name$1));
+			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({
@@ -51,12 +46,13 @@ function createCompiler(options, callback) {
 			externals
 		});
 	}
-	const compiler = rspackCore.rspack(rspackOptions, isWatch ? handler : void 0);
-	if (compiler) compiler.outputFileSystem = vfs;
-	if (!isWatch) compiler?.run(async (...args) => {
+	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) {
@@ -76,15 +72,18 @@ function normalizePackageName(name) {
 	return scope;
 }
 function resolveRspackOptions({ cwd, isEsm = true, entryFile, plugins, alias, watch = false }) {
-	const targets = ["node >= 18.0.0"];
+	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: "node18.0",
+		target: `node${(process.versions.node || "").replace(/\.\d+$/, "")}`,
 		externalsType: isEsm ? "module" : "commonjs2",
+		externals: [externalPattern],
 		resolve: {
 			alias,
 			extensions: [
@@ -100,10 +99,14 @@ function resolveRspackOptions({ cwd, isEsm = true, entryFile, plugins, alias, wa
 		output: {
 			library: { type: !isEsm ? "commonjs2" : "module" },
 			filename: "output.js",
+			module: isEsm,
 			path: "/"
 		},
-		experiments: { outputModule: isEsm },
 		optimization: { minimize: !watch },
+		node: {
+			__dirname: false,
+			__filename: false
+		},
 		module: { rules: [
 			{
 				test: /\.json5?$/,
@@ -133,192 +136,45 @@ function resolveRspackOptions({ cwd, isEsm = true, entryFile, plugins, alias, wa
 		] }
 	};
 }
-
-//#endregion
-//#region src/core/build.ts
-async function buildMockServer(options, outputDir) {
-	const entryFile = path.resolve(process.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 fsp.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 = path.resolve(outputDir, options.build.dist);
-	options.logger.info(`${color.green("✓")} generate mock server in ${color.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(` ${color.green(filename)}${space}${color.bold(color.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(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 = createFilter(include, exclude, { resolve: false });
-	return await fastGlob(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 = normalizePath(path.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 = path.dirname(entryFile);
-	if (!fs.existsSync(dirname)) await fsp.mkdir(dirname, { recursive: true });
-	await fsp.writeFile(entryFile, code, "utf8");
-}
-function getPluginPackageInfo() {
-	let pkg = {};
-	try {
-		const filepath = path.join(packageDir, "../package.json");
-		if (fs.existsSync(filepath)) pkg = JSON.parse(fs.readFileSync(filepath, "utf8"));
-	} catch {}
-	return {
-		name: pkg.name || "rspack-plugin-mock",
-		version: pkg.version || "latest"
-	};
-}
-function getHostDependencies(context) {
-	let pkg = {};
-	try {
-		const content = lookupFile(context, ["package.json"]);
-		if (content) pkg = JSON.parse(content);
-	} catch {}
-	return {
-		...pkg.dependencies,
-		...pkg.devDependencies
-	};
-}
-
 //#endregion
-//#region src/core/loadFromCode.ts
+//#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}.timestamp-${Date.now()}${ext}`;
-	const file = pathToFileURL(filepathTmp).toString();
+	const filepathTmp = `${filepath}.${getHash(code)}${ext}`;
 	await promises.writeFile(filepathTmp, code, "utf8");
-	try {
-		const mod = await import(file);
-		return mod.default || mod;
-	} finally {
-		try {
-			fs.unlinkSync(filepathTmp);
-		} catch {}
-	}
+	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/core/mockCompiler.ts
+//#region src/compiler/mockCompiler.ts
 function createMockCompiler(options) {
 	return new MockCompiler(options);
 }
 var MockCompiler = class extends EventEmitter {
 	cwd;
 	mockWatcher;
-	moduleType = "cjs";
 	entryFile;
+	deps = [];
+	isESM = false;
 	_mockData = {};
-	fileFilter;
 	watchInfo;
 	compiler;
 	constructor(options) {
 		super();
 		this.options = options;
 		this.cwd = options.cwd || process.cwd();
-		const { include, exclude } = this.options;
-		this.fileFilter = createFilter(include, exclude, { resolve: false });
 		try {
-			const pkg = lookupFile(this.cwd, ["package.json"]);
-			this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
+			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");
 	}
@@ -326,11 +182,18 @@ var MockCompiler = class extends EventEmitter {
 		return this._mockData;
 	}
 	async run() {
-		await this.updateMockEntry();
-		this.watchMockFiles();
+		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.moduleType === "esm",
+			isEsm: this.isESM,
 			cwd: this.cwd,
 			plugins,
 			entryFile: this.entryFile,
@@ -342,10 +205,10 @@ var MockCompiler = class extends EventEmitter {
 				const result = await loadFromCode({
 					filepath: "mock.bundle.js",
 					code,
-					isESM: this.moduleType === "esm",
+					isESM: this.isESM,
 					cwd: this.cwd
 				});
-				this._mockData = transformMockData(transformRawData(result));
+				this._mockData = processMockData(processRawData(result));
 				this.emit("update", this.watchInfo || {});
 			} catch (e) {
 				this.options.logger.error(e.stack || e.message);
@@ -364,93 +227,200 @@ var MockCompiler = class extends EventEmitter {
 		};
 	}
 	async updateMockEntry() {
-		const files = await this.getMockFiles();
-		await writeMockEntryFile(this.entryFile, files, this.cwd);
-	}
-	async getMockFiles() {
-		const { include } = this.options;
-		const files = await fastGlob(include, { cwd: this.cwd });
-		return files.filter(this.fileFilter);
+		await writeMockEntryFile(this.entryFile, this.deps, this.cwd, this.options.dir);
 	}
-	watchMockFiles() {
-		const { include } = this.options;
-		const [firstGlob, ...otherGlob] = toArray(include);
-		const watcher = this.mockWatcher = chokidar.watch(firstGlob, {
+	watchMockFiles(isMatch) {
+		const watcher = this.mockWatcher = chokidar.watch(this.options.dir, {
 			ignoreInitial: true,
-			cwd: this.cwd
+			cwd: this.cwd,
+			ignored: (filepath, stats) => {
+				if (filepath.includes("node_modules")) return true;
+				return !!stats?.isFile() && !isMatch(filepath);
+			}
 		});
-		if (otherGlob.length > 0) otherGlob.forEach((glob) => watcher.add(glob));
 		watcher.on("add", (filepath) => {
-			if (this.fileFilter(filepath)) {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
 				this.watchInfo = {
 					filepath,
 					type: "add"
 				};
+				this.deps = uniq([...this.deps, filepath]);
 				this.updateMockEntry();
 			}
 		});
 		watcher.on("change", (filepath) => {
-			if (this.fileFilter(filepath)) this.watchInfo = {
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) this.watchInfo = {
 				filepath,
 				type: "change"
 			};
 		});
 		watcher.on("unlink", async (filepath) => {
-			this.watchInfo = {
-				filepath,
-				type: "unlink"
-			};
-			this.updateMockEntry();
+			filepath = normalizePath(filepath);
+			if (isMatch(filepath)) {
+				this.watchInfo = {
+					filepath,
+					type: "unlink"
+				};
+				this.deps = this.deps.filter((dep) => dep !== filepath);
+				this.updateMockEntry();
+			}
 		});
 	}
 };
-
 //#endregion
-//#region src/core/mockMiddleware.ts
-function createMockMiddleware(compiler, options) {
-	return function mockMiddleware(middlewares, reload) {
-		middlewares.unshift(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 } = urlParse(req.url);
-		if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url, req))) return next();
-		const mockData = compiler.mockData;
-		const mockUrl = Object.keys(mockData).find((key) => pathToRegexp(key).test(pathname));
-		if (!mockUrl) return next();
-		cors(corsOptions)(req, res, next);
+//#region package.json
+var name = "rspack-plugin-mock";
+var version = "2.0.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/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$1 = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, { alias, context, plugins, proxies }) {
+//#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 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)
+		}
+	];
+	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/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 = {} }, { alias, context, plugins, proxies: rawProxies }) {
 	const logger = createLogger("rspack:mock", isBoolean(log) ? log ? "info" : "error" : log);
-	prefix = toArray(prefix);
+	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
+	};
 	return {
 		prefix,
 		wsPrefix,
 		cwd: cwd || context || process.cwd(),
+		dir,
 		include,
 		exclude,
 		reload,
-		cors: cors$1,
+		cors: enabled ? corsOptions : false,
 		cookiesOptions,
 		log,
 		formidableOptions: {
@@ -459,18 +429,18 @@ function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["moc
 		},
 		bodyParserOptions,
 		priority,
-		build: build ? Object.assign({
+		build: build ? {
 			serverPort: 8080,
 			dist: "mockServer",
-			log: "error"
-		}, typeof build === "object" ? build : {}) : false,
+			log: "error",
+			...typeof build === "object" ? build : {}
+		} : false,
 		alias,
 		plugins,
-		proxies: [...proxies, ...prefix],
-		wsProxies: toArray(wsPrefix),
+		proxies,
+		wsProxies,
 		logger
 	};
 }
-
 //#endregion
-export { MockCompiler, buildMockServer, createMockCompiler, createMockMiddleware, resolvePluginOptions };
+export { buildMockServer as n, createMockCompiler as r, resolvePluginOptions as t };

package/dist/rsbuild.d.ts

@@ -1,4 +1,4 @@
-import { BodyParserOptions, ExtraRequest, FormidableFile, LogLevel, LogType, Method, MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, MockOptions, MockRequest, MockResponse, MockServerPluginOptions, MockWebsocketItem, ResponseBody, ServerBuildOption, WebSocketSetupContext } from "./types-DPzh7nJq.js";
+import { _ as WebSocketSetupContext, a as LogType, c as MockMatchPriority, d as MockRequest, f as MockResponse, g as ServerBuildOption, h as ResponseBody, i as LogLevel, l as MockMatchSpecialPriority, m as MockWebsocketItem, n as ExtraRequest, o as Method, p as MockServerPluginOptions, r as FormidableFile, s as MockHttpItem, t as BodyParserOptions, u as MockOptions } from "./types-GT6M6WuI.js";
 import { RsbuildPlugin } from "@rsbuild/core";
 
 //#region src/rsbuild.d.ts