rspack-plugin-mock 1.2.0 → 1.3.0

package/dist/resolvePluginOptions-DlkIkykz.js

@@ -1,476 +0,0 @@
-import { baseMiddleware, createLogger, doesProxyContextMatchUrl, lookupFile, normalizePath, packageDir, transformMockData, transformRawData, urlParse, vfs } from "./logger-C48_LmdS.js";
-import { createRequire } from "node:module";
-import { isBoolean, toArray } from "@pengzhanbo/utils";
-import EventEmitter from "node:events";
-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 fs, { promises } from "node:fs";
-import fsp from "node:fs/promises";
-import color from "picocolors";
-import * as rspackCore from "@rspack/core";
-import isCore from "is-core-module";
-import { pathToFileURL } from "node:url";
-import { pathToRegexp } from "path-to-regexp";
-import cors from "cors";
-
-//#region src/core/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(color.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 = 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));
-			}
-		}
-		await callback({
-			code,
-			externals
-		});
-	}
-	const compiler = rspackCore.rspack(rspackOptions, isWatch ? handler : void 0);
-	if (compiler) compiler.outputFileSystem = 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.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 = 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
-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();
-	await promises.writeFile(filepathTmp, code, "utf8");
-	try {
-		const mod = await import(file);
-		return mod.default || mod;
-	} finally {
-		try {
-			fs.unlinkSync(filepathTmp);
-		} catch {}
-	}
-}
-
-//#endregion
-//#region src/core/mockCompiler.ts
-function createMockCompiler(options) {
-	return new MockCompiler(options);
-}
-var MockCompiler = class extends EventEmitter {
-	cwd;
-	mockWatcher;
-	moduleType = "cjs";
-	entryFile;
-	_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";
-		} catch {}
-		this.entryFile = path.resolve(process.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 = transformMockData(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 fastGlob(include, { cwd: this.cwd });
-		return files.filter(this.fileFilter);
-	}
-	watchMockFiles() {
-		const { include } = this.options;
-		const [firstGlob, ...otherGlob] = toArray(include);
-		const watcher = this.mockWatcher = chokidar.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(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);
-	};
-}
-
-//#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 }) {
-	const logger = createLogger("rspack:mock", isBoolean(log) ? log ? "info" : "error" : log);
-	prefix = toArray(prefix);
-	return {
-		prefix,
-		wsPrefix,
-		cwd: cwd || context || process.cwd(),
-		include,
-		exclude,
-		reload,
-		cors: cors$1,
-		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: toArray(wsPrefix),
-		logger
-	};
-}
-
-//#endregion
-export { MockCompiler, buildMockServer, createMockCompiler, createMockMiddleware, resolvePluginOptions };

package/dist/rsbuild.cjs

@@ -1,176 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_logger = require('./logger-C0V8Cvvd.cjs');
-const require_resolvePluginOptions = require('./resolvePluginOptions-Da5uqlBx.cjs');
-const __pengzhanbo_utils = require_chunk.__toESM(require("@pengzhanbo/utils"));
-const node_path = require_chunk.__toESM(require("node:path"));
-const node_process = require_chunk.__toESM(require("node:process"));
-const picocolors = require_chunk.__toESM(require("picocolors"));
-const __rspack_core = require_chunk.__toESM(require("@rspack/core"));
-const node_http = require_chunk.__toESM(require("node:http"));
-const portfinder = require_chunk.__toESM(require("portfinder"));
-
-//#region src/rsbuild.ts
-function pluginMockServer(options = {}) {
-	return {
-		name: "plugin-mock-server",
-		setup(api) {
-			const rsbuildConfig = api.getRsbuildConfig();
-			const resolvedOptions = require_resolvePluginOptions.resolvePluginOptions(options, {
-				proxies: resolveConfigProxies(rsbuildConfig),
-				alias: {},
-				context: api.context.rootPath,
-				plugins: [new __rspack_core.default.DefinePlugin(rsbuildConfig.source?.define || {})]
-			});
-			if (node_process.default.env.NODE_ENV === "production") {
-				if (resolvedOptions.build) api.onAfterBuild(async () => {
-					const config = api.getNormalizedConfig();
-					await require_resolvePluginOptions.buildMockServer(resolvedOptions, node_path.default.resolve(node_process.default.cwd(), config.output.distPath.root || "dist"));
-				});
-				return;
-			}
-			const mockCompiler = require_resolvePluginOptions.createMockCompiler(resolvedOptions);
-			api.modifyRsbuildConfig((config) => {
-				updateServerProxyConfigByHttpMock(config);
-				const mockMiddleware = require_resolvePluginOptions.createMockMiddleware(mockCompiler, resolvedOptions);
-				config.dev ??= {};
-				config.dev.setupMiddlewares ??= [];
-				config.dev.setupMiddlewares.push((middlewares, server$1) => {
-					mockMiddleware(middlewares, () => server$1.sockWrite("static-changed"));
-				});
-			});
-			let port = 3079;
-			const shouldMockWs = (0, __pengzhanbo_utils.toArray)(resolvedOptions.wsPrefix).length > 0;
-			if (shouldMockWs) api.modifyRsbuildConfig(async (config) => {
-				const defaultPort = (config.server?.port || port) + 1;
-				port = await (0, portfinder.getPortPromise)({ port: defaultPort });
-				updateServerProxyConfigByWSMock(config, options.wsPrefix || [], port);
-			});
-			let server;
-			function startMockServer() {
-				mockCompiler.run();
-				if (shouldMockWs) {
-					server = (0, node_http.createServer)();
-					require_logger.mockWebSocket(mockCompiler, server, resolvedOptions);
-					server.listen(port);
-				}
-			}
-			function close() {
-				mockCompiler.close();
-				server?.close();
-			}
-			api.onAfterCreateCompiler(({ compiler }) => {
-				if ("compilers" in compiler) compiler.compilers.forEach((compiler$1) => {
-					mockCompiler.updateAlias(compiler$1.options.resolve?.alias || {});
-				});
-				else mockCompiler.updateAlias(compiler.options.resolve?.alias || {});
-			});
-			api.onAfterStartDevServer(startMockServer);
-			api.onAfterStartProdServer(startMockServer);
-			api.onExit(close);
-		}
-	};
-}
-function onProxyError(err, _req, res) {
-	console.error(picocolors.default.red(err?.stack || err.message));
-	res.statusCode = 500;
-	res.end();
-}
-function updateServerProxyConfigByHttpMock(config) {
-	if (!config.server?.proxy) return;
-	if ((0, __pengzhanbo_utils.isArray)(config.server.proxy)) config.server.proxy = config.server.proxy.map((item) => {
-		if (typeof item !== "function" && !item.ws) {
-			const onProxyReq = item.onProxyReq;
-			const onError = item.onError;
-			return {
-				...item,
-				onError: onError || onProxyError,
-				onProxyReq: (proxyReq, req, ...args) => {
-					onProxyReq?.(proxyReq, req, ...args);
-					require_logger.rewriteRequest(proxyReq, req);
-				}
-			};
-		}
-		return item;
-	});
-	else if ("target" in config.server.proxy) {
-		const onProxyReq = config.server.proxy.onProxyReq;
-		config.server.proxy.onProxyReq = (proxyReq, req, ...args) => {
-			onProxyReq?.(proxyReq, req, ...args);
-			require_logger.rewriteRequest(proxyReq, req);
-		};
-		config.server.proxy.onError ??= onProxyError;
-	} 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;
-			const { onProxyReq, onError,...rest } = options;
-			proxy[key] = {
-				...rest,
-				onProxyReq: (proxyReq, req, ...args) => {
-					onProxyReq?.(proxyReq, req, ...args);
-					require_logger.rewriteRequest(proxyReq, req);
-				},
-				onError: onError || onProxyError
-			};
-		});
-	}
-}
-function updateServerProxyConfigByWSMock(config, wsPrefix, port) {
-	config.server ??= {};
-	const proxy = config.server.proxy ??= {};
-	const wsTarget = `ws://localhost:${port}`;
-	const prefix = (0, __pengzhanbo_utils.toArray)(wsPrefix);
-	const has = (context) => typeof context === "string" && prefix.includes(context);
-	const used = /* @__PURE__ */ new Set();
-	function updateProxy(item) {
-		if ((0, __pengzhanbo_utils.isArray)(item.context)) item.context = item.context.filter(has);
-		else if (has(item.context)) {
-			used.add(item.context);
-			item.target = wsTarget;
-		}
-	}
-	if ((0, __pengzhanbo_utils.isArray)(proxy)) {
-		for (const item of proxy) if (typeof item !== "function" && item.context && item.ws) updateProxy(item);
-		prefix.filter((context) => !used.has(context)).forEach((context) => proxy.push({
-			context,
-			target: wsTarget
-		}));
-	} else if ("target" in proxy) {
-		if (proxy.ws) {
-			updateProxy(proxy);
-			const list = config.server.proxy = [proxy];
-			prefix.filter((context) => !used.has(context)).forEach((context) => list.push({
-				context,
-				target: wsTarget
-			}));
-		}
-	} else {
-		Object.entries(proxy).forEach(([, opt]) => {
-			if (typeof opt !== "string" && opt.ws) updateProxy(opt);
-		});
-		prefix.filter((context) => !used.has(context)).forEach((context) => {
-			proxy[context] = {
-				target: wsTarget,
-				ws: true
-			};
-		});
-	}
-}
-function resolveConfigProxies(config) {
-	config.server ??= {};
-	const proxy = config.server.proxy ??= {};
-	const proxies = [];
-	if ((0, __pengzhanbo_utils.isArray)(proxy)) {
-		for (const item of proxy) if (typeof item !== "function" && item.context && !item.ws) proxies.push(...(0, __pengzhanbo_utils.toArray)(item.context));
-	} else if ("target" in proxy) {
-		if (!proxy.ws) proxies.push(...(0, __pengzhanbo_utils.toArray)(proxy.context));
-	} else Object.entries(proxy).forEach(([context, opt]) => {
-		if (typeof opt === "string" || !opt.ws) proxies.push(context);
-	});
-	return proxies;
-}
-
-//#endregion
-exports.pluginMockServer = pluginMockServer;

package/dist/rsbuild.d.cts

@@ -1,7 +0,0 @@
-import { BodyParserOptions, ExtraRequest, FormidableFile, LogLevel, LogType, Method, MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, MockOptions, MockRequest, MockResponse, MockServerPluginOptions, MockWebsocketItem, ResponseBody, ServerBuildOption, WebSocketSetupContext } from "./types-6lajtJPx.cjs";
-import { RsbuildPlugin } from "@rsbuild/core";
-
-//#region src/rsbuild.d.ts
-declare function pluginMockServer(options?: MockServerPluginOptions): RsbuildPlugin;
-//#endregion
-export { BodyParserOptions, ExtraRequest, FormidableFile, LogLevel, LogType, Method, MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, MockOptions, MockRequest, MockResponse, MockServerPluginOptions, MockWebsocketItem, ResponseBody, ServerBuildOption, WebSocketSetupContext, pluginMockServer };

package/dist/rsbuild.d.ts

@@ -1,7 +0,0 @@
-import { BodyParserOptions, ExtraRequest, FormidableFile, LogLevel, LogType, Method, MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, MockOptions, MockRequest, MockResponse, MockServerPluginOptions, MockWebsocketItem, ResponseBody, ServerBuildOption, WebSocketSetupContext } from "./types-DPzh7nJq.js";
-import { RsbuildPlugin } from "@rsbuild/core";
-
-//#region src/rsbuild.d.ts
-declare function pluginMockServer(options?: MockServerPluginOptions): RsbuildPlugin;
-//#endregion
-export { BodyParserOptions, ExtraRequest, FormidableFile, LogLevel, LogType, Method, MockHttpItem, MockMatchPriority, MockMatchSpecialPriority, MockOptions, MockRequest, MockResponse, MockServerPluginOptions, MockWebsocketItem, ResponseBody, ServerBuildOption, WebSocketSetupContext, pluginMockServer };