rspack-plugin-mock/dist/index.js

inject api mock server to development server

import { a as rewriteRequest, c as processRawData, i as createMockMiddleware, l as sortByValidator, n as logLevels, o as Recorder, r as mockWebSocket, s as processMockData, t as createLogger, u as waitingFor } 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 "./server.js";
import path from "node:path";
import process from "node:process";
import { isFunction, isString, toArray, toTruthy } from "@pengzhanbo/utils";
import rspack from "@rspack/core";
//#region src/core/rspack.ts
const PLUGIN_NAME = "rspack-plugin-mock";
var MockServerPlugin = class {
	constructor(options = {}) {
		this.options = options;
	}
	apply(compiler) {
		if (this.options.enabled === false) return;
		const compilerOptions = compiler.options;
		const options = this.resolvePluginOptions(compiler, this.options);
		const isProd = process.env.NODE_ENV === "production";
		if (isProd && options.build !== false) compiler.hooks.afterEmit.tap(PLUGIN_NAME, () => buildMockServer(options, compilerOptions.output.path || path.resolve(process.cwd(), "dist")));
		if (isProd) return;
		if (compilerOptions.devServer === false) {
			options.logger.warn(`Not find devServer, ${PLUGIN_NAME} was disabled`);
			return;
		}
		const devServer = compilerOptions.devServer ||= {};
		const mockCompiler = createMockCompiler(options);
		this.provideMiddleware(mockCompiler, devServer, options);
		this.provideProxyConfig(options, devServer);
		compiler.hooks.watchRun.tap(PLUGIN_NAME, () => mockCompiler.run());
		compiler.hooks.watchClose.tap(PLUGIN_NAME, () => mockCompiler.close());
	}
	provideMiddleware(mockCompiler, devServer, options) {
		const setupMiddlewares = devServer.setupMiddlewares;
		const waitServerForMockWebSocket = waitingFor((server) => {
			mockWebSocket(mockCompiler, server, options);
		});
		devServer.setupMiddlewares = function(middlewares, devServer) {
			middlewares = setupMiddlewares?.(middlewares, devServer) || middlewares;
			middlewares.unshift(createMockMiddleware(mockCompiler, options));
			if (options.reload) mockCompiler.on("update", () => {
				if (devServer.webSocketServer?.clients) devServer.sendMessage(devServer.webSocketServer.clients, "static-changed");
			});
			/**
			* 在 @rspack/dev-server 中, setupMiddlewares 优先于 createServer
			* 执行，需要等待 server 启动后再注入 mock websocket
			*/
			waitServerForMockWebSocket(() => devServer.server);
			return middlewares;
		};
	}
	provideProxyConfig(options, devServer) {
		if (!devServer.proxy?.length) return;
		const wsPrefix = toArray(options.wsPrefix);
		let recorder = null;
		if (options.record.enabled) recorder = new Recorder(options.record);
		devServer.proxy = devServer.proxy.filter((item) => {
			if (!isFunction(item) && item.ws === true && wsPrefix.length) return !toArray(item.pathFilter || item.context).filter(isString).some((context) => wsPrefix.includes(context));
			return true;
		}).map((item) => {
			if (!isFunction(item) && !item.ws) {
				const plugins = item.plugins ??= [];
				plugins.push((proxyServer) => proxyServer.on("proxyReq", rewriteRequest));
				if (options.record.enabled && recorder) plugins.push(recorder.getPlugin());
			}
			return item;
		});
	}
	resolvePluginOptions(compiler, options = {}) {
		const compilerOptions = compiler.options;
		const alias = compilerOptions.resolve?.alias || {};
		const context = compilerOptions.context;
		const definePluginInstance = compilerOptions.plugins?.find((plugin) => plugin instanceof rspack.DefinePlugin);
		const proxies = ((compilerOptions.devServer || {}).proxy || []).flatMap((item) => {
			if (!isFunction(item) && !item.ws) return item.pathFilter || item.context;
			return [];
		}).filter(toTruthy);
		return resolvePluginOptions(options, {
			alias,
			context,
			plugins: toArray(definePluginInstance),
			proxies
		});
	}
};
//#endregion
export { MockServerPlugin, createDefineMock, createLogger, createMockMiddleware, createSSEStream, defineMock, defineMockData, logLevels, mockWebSocket, processMockData, processRawData, sortByValidator };