vite-plugin-mock-dev-server 1.9.2 → 2.0.0

package/dist/index.js

@@ -1,36 +1,34 @@
-import { isArray, isBoolean, promiseParallel, toArray, uniq } from "./dist-CAA1v47s.js";
-import { createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper-DhHU-YoO.js";
-import { baseMiddleware, createLogger, debug, doesProxyContextMatchUrl, ensureProxies, logLevels, lookupFile, mockWebSocket, normalizePath, recoverRequest, sortByValidator, transformMockData, transformRawData, urlParse } from "./server-C-u7jwot.js";
-import pc from "picocolors";
+import { createLogger, createMatcher, createMockMiddleware, debug, doesProxyContextMatchUrl, isPathMatch, logLevels, mockWebSocket, normalizePath, processMockData, processRawData, recoverRequest, sortByValidator, urlParse } from "./server-D-sv_WW9.js";
+import { createDefineMock, createSSEStream, defineMock, defineMockData } from "./helper-BbR8Si2U.js";
+import { isArray, isBoolean, promiseParallel, toArray, uniq } from "@pengzhanbo/utils";
 import fs, { promises } from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
-import { createFilter } from "@rollup/pluginutils";
-import fg from "fast-glob";
-import isCore from "is-core-module";
+import ansis from "ansis";
+import { getPackageInfoSync, isPackageExists, loadPackageJSON, loadPackageJSONSync } from "local-pkg";
 import { pathToFileURL } from "node:url";
-import { build } from "esbuild";
 import JSON5 from "json5";
-import { pathToRegexp } from "path-to-regexp";
-import cors from "cors";
 import EventEmitter from "node:events";
-import chokidar from "chokidar";
+import { watch } from "chokidar";
+import { glob } from "tinyglobby";
+import isCore from "is-core-module";
+import cors from "cors";
 
-//#region src/core/compiler.ts
+//#region src/compiler/esbuild.ts
 const externalizeDeps = {
 	name: "externalize-deps",
-	setup(build$1) {
-		build$1.onResolve({ filter: /.*/ }, ({ path: id }) => {
+	setup(build) {
+		build.onResolve({ filter: /.*/ }, ({ path: id }) => {
 			if (id[0] !== "." && !path.isAbsolute(id)) return { external: true };
 		});
 	}
 };
 const json5Loader = {
 	name: "json5-loader",
-	setup(build$1) {
-		build$1.onLoad({ filter: /\.json5$/ }, async ({ path: path$1 }) => {
-			const content = await promises.readFile(path$1, "utf-8");
+	setup(build) {
+		build.onLoad({ filter: /\.json5$/ }, async ({ path: path$1 }) => {
+			const content = await fsp.readFile(path$1, "utf-8");
 			return {
 				contents: `export default ${JSON.stringify(JSON5.parse(content))}`,
 				loader: "js"
@@ -40,9 +38,9 @@ const json5Loader = {
 };
 const jsonLoader = {
 	name: "json-loader",
-	setup(build$1) {
-		build$1.onLoad({ filter: /\.json$/ }, async ({ path: path$1 }) => {
-			const content = await promises.readFile(path$1, "utf-8");
+	setup(build) {
+		build.onLoad({ filter: /\.json$/ }, async ({ path: path$1 }) => {
+			const content = await fsp.readFile(path$1, "utf-8");
 			return {
 				contents: `export default ${content}`,
 				loader: "js"
@@ -50,10 +48,10 @@ const jsonLoader = {
 		});
 	}
 };
-const renamePlugin = {
+const renamePlugin$1 = {
 	name: "rename-plugin",
-	setup(build$1) {
-		build$1.onResolve({ filter: /.*/ }, ({ path: id }) => {
+	setup(build) {
+		build.onResolve({ filter: /.*/ }, ({ path: id }) => {
 			if (id === "vite-plugin-mock-dev-server") return {
 				path: "vite-plugin-mock-dev-server/helper",
 				external: true
@@ -65,12 +63,12 @@ const renamePlugin = {
 function aliasPlugin(alias) {
 	return {
 		name: "alias-plugin",
-		setup(build$1) {
-			build$1.onResolve({ filter: /.*/ }, async ({ path: id }) => {
+		setup(build) {
+			build.onResolve({ filter: /.*/ }, async ({ path: id }) => {
 				const matchedEntry = alias.find(({ find: find$1 }) => aliasMatches(find$1, id));
 				if (!matchedEntry) return null;
 				const { find, replacement } = matchedEntry;
-				const result = await build$1.resolve(id.replace(find, replacement), {
+				const result = await build.resolve(id.replace(find, replacement), {
 					kind: "import-statement",
 					resolveDir: replacement,
 					namespace: "file"
@@ -89,12 +87,17 @@ function aliasMatches(pattern, importee) {
 	if (importee === pattern) return true;
 	return importee.startsWith(`${pattern}/`);
 }
-async function transformWithEsbuild(entryPoint, options) {
-	const { isESM = true, define, alias, cwd = process.cwd() } = options;
+let _build = null;
+async function esbuild() {
+	_build ||= (await import("esbuild")).build;
+	return _build;
+}
+async function transformWithEsbuild(entryPoint, { isESM = true, define, alias, cwd = process.cwd() }) {
 	const filepath = path.resolve(cwd, entryPoint);
 	const filename = path.basename(entryPoint);
 	const dirname = path.dirname(filepath);
 	try {
+		const build = await esbuild();
 		const result = await build({
 			entryPoints: [entryPoint],
 			outfile: "out.js",
@@ -112,25 +115,31 @@ async function transformWithEsbuild(entryPoint, options) {
 			},
 			plugins: [
 				aliasPlugin(alias),
-				renamePlugin,
+				renamePlugin$1,
 				externalizeDeps,
 				jsonLoader,
 				json5Loader
 			],
 			absWorkingDir: cwd
 		});
+		const deps = /* @__PURE__ */ new Set();
+		const inputs = result.metafile?.inputs || {};
+		Object.keys(inputs).forEach((key) => inputs[key].imports.forEach((dep) => deps.add(dep.path)));
 		return {
 			code: result.outputFiles[0].text,
-			deps: result.metafile?.inputs || {}
+			deps: Array.from(deps)
 		};
 	} catch (e) {
 		console.error(e);
 	}
 	return {
 		code: "",
-		deps: {}
+		deps: []
 	};
 }
+
+//#endregion
+//#region src/compiler/loadFromCode.ts
 async function loadFromCode({ filepath, code, isESM, cwd }) {
 	filepath = path.resolve(cwd, filepath);
 	const ext = isESM ? ".mjs" : ".cjs";
@@ -148,222 +157,203 @@ async function loadFromCode({ filepath, code, isESM, cwd }) {
 }
 
 //#endregion
-//#region src/core/build.ts
-async function generateMockServer(ctx, options) {
-	const include = toArray(options.include);
-	const exclude = toArray(options.exclude);
-	const cwd = options.cwd || process.cwd();
-	let pkg = {};
-	try {
-		const pkgStr = lookupFile(options.context, ["package.json"]);
-		if (pkgStr) pkg = JSON.parse(pkgStr);
-	} catch {}
-	const outputDir = options.build.dist;
-	const content = await generateMockEntryCode(cwd, include, exclude);
-	const mockEntry = path.join(cwd, `mock-data-${Date.now()}.js`);
-	await fsp.writeFile(mockEntry, content, "utf-8");
-	const { code, deps } = await transformWithEsbuild(mockEntry, options);
-	const mockDeps = getMockDependencies(deps, options.alias);
-	await fsp.unlink(mockEntry);
-	const outputList = [
-		{
-			filename: path.join(outputDir, "mock-data.js"),
-			source: code
-		},
-		{
-			filename: path.join(outputDir, "index.js"),
-			source: generatorServerEntryCode(options)
-		},
-		{
-			filename: path.join(outputDir, "package.json"),
-			source: generatePackageJson(pkg, mockDeps)
+//#region src/compiler/rolldown.ts
+const renamePlugin = {
+	name: "vite-mock:rename-plugin",
+	resolveId(id) {
+		if (id === "vite-plugin-mock-dev-server") return {
+			id: "vite-plugin-mock-dev-server/helper",
+			external: true
+		};
+	}
+};
+const json5Plugin = {
+	name: "vite-mock:json5-plugin",
+	transform: {
+		filter: { id: /\.json5$/ },
+		handler: (code) => {
+			return { code: `export default ${JSON5.stringify(JSON5.parse(code))}` };
 		}
-	];
+	}
+};
+let _rolldown = null;
+async function rolldown() {
+	_rolldown ||= {
+		build: (await import("rolldown")).build,
+		aliasPlugin: (await import("rolldown/experimental")).aliasPlugin
+	};
+	return _rolldown;
+}
+async function transformWithRolldown(entryPoint, { isESM = true, define, alias, cwd = process.cwd() }) {
+	const filepath = path.resolve(cwd, entryPoint);
+	const filename = path.basename(entryPoint);
+	const dirname = path.dirname(filepath);
+	const isAlias = (p) => !!alias.find(({ find }) => aliasMatches(find, p));
 	try {
-		if (path.isAbsolute(outputDir)) {
-			for (const { filename } of outputList) if (fs.existsSync(filename)) await fsp.rm(filename);
-			options.logger.info(`${pc.green("✓")} generate mock server in ${pc.cyan(outputDir)}`);
-			for (const { filename, source } of outputList) {
-				fs.mkdirSync(path.dirname(filename), { recursive: true });
-				await fsp.writeFile(filename, source, "utf-8");
-				const sourceSize = (source.length / 1024).toFixed(2);
-				const name = path.relative(outputDir, filename);
-				const space = name.length < 30 ? " ".repeat(30 - name.length) : "";
-				options.logger.info(`  ${pc.green(name)}${space}${pc.bold(pc.dim(`${sourceSize} kB`))}`);
-			}
-		} else for (const { filename, source } of outputList) ctx.emitFile({
-			type: "asset",
-			fileName: filename,
-			source
+		const { build, aliasPlugin: aliasPlugin$1 } = await rolldown();
+		const result = await build({
+			input: entryPoint,
+			write: false,
+			cwd,
+			output: {
+				format: isESM ? "esm" : "cjs",
+				sourcemap: false,
+				file: "out.js"
+			},
+			platform: "node",
+			define: {
+				...define,
+				__dirname: JSON.stringify(dirname),
+				__filename: JSON.stringify(filename),
+				...isESM ? {} : { "import.meta.url": JSON.stringify(pathToFileURL(filepath)) }
+			},
+			external(id) {
+				if (isAlias(id)) return false;
+				if (id[0] !== "." && !path.isAbsolute(id) && id !== "vite-plugin-mock-dev-server") return true;
+			},
+			plugins: [
+				aliasPlugin$1({ entries: alias }),
+				renamePlugin,
+				json5Plugin
+			]
 		});
+		return {
+			code: result.output[0].code,
+			deps: result.output[0].imports
+		};
 	} catch (e) {
 		console.error(e);
 	}
-}
-function getMockDependencies(deps, alias) {
-	const list = /* @__PURE__ */ new Set();
-	const excludeDeps = [
-		"vite-plugin-mock-dev-server",
-		"connect",
-		"cors"
-	];
-	const isAlias = (p) => alias.find(({ find }) => aliasMatches(find, p));
-	Object.keys(deps).forEach((mPath) => {
-		const imports = deps[mPath].imports.filter((_) => _.external && !_.path.startsWith("<define:") && !isAlias(_.path)).map((_) => _.path);
-		imports.forEach((dep) => {
-			const name = normalizePackageName(dep);
-			if (!excludeDeps.includes(name) && !isCore(name)) list.add(name);
-		});
-	});
-	return Array.from(list);
-}
-function normalizePackageName(dep) {
-	const [scope, name] = dep.split("/");
-	if (scope[0] === "@") return `${scope}/${name}`;
-	return scope;
-}
-function generatePackageJson(pkg, mockDeps) {
-	const { dependencies = {}, devDependencies = {} } = pkg;
-	const dependents = {
-		...dependencies,
-		...devDependencies
-	};
-	const mockPkg = {
-		name: "mock-server",
-		type: "module",
-		scripts: { start: "node index.js" },
-		dependencies: {
-			connect: "^3.7.0",
-			["vite-plugin-mock-dev-server"]: `^1.9.1`,
-			cors: "^2.8.5"
-		},
-		pnpm: { peerDependencyRules: { ignoreMissing: ["vite"] } }
+	return {
+		code: "",
+		deps: []
 	};
-	mockDeps.forEach((dep) => {
-		mockPkg.dependencies[dep] = dependents[dep] || "latest";
-	});
-	return JSON.stringify(mockPkg, null, 2);
 }
-function generatorServerEntryCode({ proxies, wsProxies, cookiesOptions, bodyParserOptions, priority, build: build$1 }) {
-	const { serverPort, log } = build$1;
-	return `import { createServer } from 'node:http';
-import connect from 'connect';
-import corsMiddleware from 'cors';
-import { baseMiddleware, createLogger, mockWebSocket } from 'vite-plugin-mock-dev-server/server';
-import mockData 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(wsProxies)};
-const cookiesOptions = ${JSON.stringify(cookiesOptions)};
-const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
-const priority = ${JSON.stringify(priority)};
-const compiler = { mockData }
-
-mockWebSocket(compiler, server, { wsProxies, cookiesOptions, logger });
-
-app.use(corsMiddleware());
-app.use(baseMiddleware(compiler, {
-  formidableOptions: { multiples: true },
-  proxies,
-  priority,
-  cookiesOptions,
-  bodyParserOptions,
-  logger,
-}));
-
-server.listen(${serverPort});
-
-console.log('listen: http://localhost:${serverPort}');
-`;
+//#endregion
+//#region src/compiler/compile.ts
+const hasRolldown = isPackageExists("rolldown");
+const hasEsbuild = isPackageExists("esbuild");
+async function transform(entryPoint, options) {
+	if (hasRolldown) return transformWithRolldown(entryPoint, options);
+	if (hasEsbuild) return transformWithEsbuild(entryPoint, options);
+	throw new Error("rolldown or esbuild not found");
 }
-async function generateMockEntryCode(cwd, include, exclude) {
-	const includePaths = await fg(include, { cwd });
-	const includeFilter = createFilter(include, exclude, { resolve: false });
-	const mockFiles = includePaths.filter(includeFilter);
-	let importers = "";
-	const exporters = [];
-	mockFiles.forEach((filepath, index) => {
-		const file = normalizePath(path.join(cwd, filepath));
-		importers += `import * as m${index} from '${file}';\n`;
-		exporters.push(`[m${index}, '${filepath}']`);
+async function compile(filepath, options) {
+	let isESM = false;
+	if (/\.m[jt]s$/.test(filepath)) isESM = true;
+	else if (/\.c[jt]s$/.test(filepath)) isESM = false;
+	else isESM = options.isESM || false;
+	const { code, deps } = await transform(filepath, {
+		...options,
+		isESM
 	});
-	return `import { transformMockData, transformRawData } from 'vite-plugin-mock-dev-server/server';
-${importers}
-const exporters = [\n  ${exporters.join(",\n  ")}\n];
-const mockList = exporters.map(([mod, filepath]) => {
-  const raw = mod.default || mod;
-  return transformRawData(raw, filepath);
-});
-export default transformMockData(mockList);`;
+	const data = await loadFromCode({
+		filepath,
+		code,
+		isESM,
+		cwd: options.cwd || process.cwd()
+	}) || {};
+	return {
+		data,
+		deps
+	};
 }
 
 //#endregion
-//#region src/core/mockCompiler.ts
-function createMockCompiler(options) {
-	return new MockCompiler(options);
-}
+//#region src/compiler/compiler.ts
 /**
-* mock配置加载器
+* Mock 文件加载编译，并转换为 Mock 数据
 */
-var MockCompiler = class extends EventEmitter {
+var Compiler = class extends EventEmitter {
 	moduleCache = /* @__PURE__ */ new Map();
 	moduleDeps = /* @__PURE__ */ new Map();
 	cwd;
 	mockWatcher;
 	depsWatcher;
-	moduleType = "cjs";
+	isESM = false;
 	_mockData = {};
 	constructor(options) {
 		super();
 		this.options = options;
 		this.cwd = options.cwd || process.cwd();
 		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 {}
 	}
 	get mockData() {
 		return this._mockData;
 	}
-	run() {
+	run(watch$1) {
 		const { include, exclude } = this.options;
-		/**
-		* 使用 rollup 提供的 include/exclude 规则，
-		* 过滤包含文件
-		*/
-		const includeFilter = createFilter(include, exclude, { resolve: false });
-		fg(include, { cwd: this.cwd }).then((files) => files.filter(includeFilter).map((file) => () => this.loadMock(file))).then((loadList) => promiseParallel(loadList, 10)).then(() => this.updateMockList());
-		this.watchMockEntry();
+		const { pattern, ignore, isMatch } = createMatcher(include, exclude);
+		glob(pattern, {
+			ignore,
+			cwd: path.join(this.cwd, this.options.dir)
+		}).then((files) => files.map((file) => () => this.load(path.join(this.options.dir, file)))).then((loaders) => promiseParallel(loaders, 64)).then(() => this.updateMockData());
+		if (!watch$1) return;
+		this.watchMockEntry(isMatch);
 		this.watchDeps();
 		let timer = null;
 		this.on("mock:update", async (filepath) => {
-			if (!includeFilter(filepath)) return;
-			await this.loadMock(filepath);
+			if (!isMatch(filepath)) return;
+			await this.load(filepath);
 			if (timer) clearImmediate(timer);
 			timer = setImmediate(() => {
-				this.updateMockList();
-				this.emit("mock:update-end", filepath);
+				this.updateMockData();
+				this.emit("mock:update-end", normalizePath(filepath));
 				timer = null;
 			});
 		});
 		this.on("mock:unlink", async (filepath) => {
-			if (!includeFilter(filepath)) return;
+			if (!isMatch(filepath)) return;
+			filepath = normalizePath(path.join(this.options.dir, filepath));
 			this.moduleCache.delete(filepath);
-			this.updateMockList();
+			this.updateMockData();
 			this.emit("mock:update-end", filepath);
 		});
 	}
-	watchMockEntry() {
-		const { include } = this.options;
-		const [firstGlob, ...otherGlob] = toArray(include);
-		const watcher = this.mockWatcher = chokidar.watch(firstGlob, {
+	close() {
+		this.mockWatcher?.close();
+		this.depsWatcher?.close();
+	}
+	async load(filepath) {
+		if (!filepath) return;
+		try {
+			const { define, alias } = this.options;
+			const { data, deps } = await compile(filepath, {
+				cwd: this.cwd,
+				isESM: this.isESM,
+				define,
+				alias
+			});
+			this.moduleCache.set(filepath, processRawData(data, filepath));
+			this.updateModuleDeps(filepath, deps);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+	updateMockData() {
+		this._mockData = processMockData(this.moduleCache);
+	}
+	updateModuleDeps(filepath, deps) {
+		for (const dep of deps) {
+			if (!this.moduleDeps.has(dep)) this.moduleDeps.set(dep, /* @__PURE__ */ new Set());
+			const cur = this.moduleDeps.get(dep);
+			cur.add(filepath);
+		}
+		this.emit("update:deps");
+	}
+	watchMockEntry(isMatch) {
+		const watcher = this.mockWatcher = 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", async (filepath) => {
 			filepath = normalizePath(filepath);
 			this.emit("mock:update", filepath);
@@ -380,131 +370,212 @@ var MockCompiler = class extends EventEmitter {
 			debug("watcher:unlink", filepath);
 		});
 	}
-	/**
-	* 监听 mock文件依赖的本地文件变动，
-	* mock依赖文件更新，mock文件也一并更新
-	*/
 	watchDeps() {
-		const oldDeps = [];
-		this.depsWatcher = chokidar.watch([], {
+		let oldDeps = [...this.moduleDeps.keys()];
+		const watcher = this.depsWatcher = watch([...oldDeps], {
 			ignoreInitial: true,
 			cwd: this.cwd
 		});
-		this.depsWatcher.on("change", (filepath) => {
+		watcher.on("change", (filepath) => {
 			filepath = normalizePath(filepath);
 			const mockFiles = this.moduleDeps.get(filepath);
-			mockFiles?.forEach((file) => {
-				this.emit("mock:update", file);
-			});
+			mockFiles?.forEach((file) => this.emit("mock:update", file));
 		});
-		this.depsWatcher.on("unlink", (filepath) => {
+		watcher.on("unlink", (filepath) => {
 			filepath = normalizePath(filepath);
 			this.moduleDeps.delete(filepath);
 		});
 		this.on("update:deps", () => {
-			const deps = [];
-			for (const [dep] of this.moduleDeps.entries()) deps.push(dep);
+			const deps = [...this.moduleDeps.keys()];
 			const exactDeps = deps.filter((dep) => !oldDeps.includes(dep));
-			if (exactDeps.length > 0) this.depsWatcher.add(exactDeps);
+			oldDeps = deps;
+			if (exactDeps.length > 0) watcher.add(exactDeps);
 		});
 	}
-	close() {
-		this.mockWatcher?.close();
-		this.depsWatcher?.close();
-	}
-	updateMockList() {
-		this._mockData = transformMockData(this.moduleCache);
-	}
-	updateModuleDeps(filepath, deps) {
-		Object.keys(deps).forEach((mPath) => {
-			const imports = deps[mPath].imports.map((_) => _.path);
-			imports.forEach((dep) => {
-				if (!this.moduleDeps.has(dep)) this.moduleDeps.set(dep, /* @__PURE__ */ new Set());
-				const cur = this.moduleDeps.get(dep);
-				cur.add(filepath);
-			});
-		});
-		this.emit("update:deps");
-	}
-	async loadMock(filepath) {
-		if (!filepath) return;
-		let isESM = false;
-		if (/\.m[jt]s$/.test(filepath)) isESM = true;
-		else if (/\.c[jt]s$/.test(filepath)) isESM = false;
-		else isESM = this.moduleType === "esm";
-		const { define, alias } = this.options;
-		const { code, deps } = await transformWithEsbuild(filepath, {
-			isESM,
-			define,
-			alias,
-			cwd: this.cwd
-		});
-		try {
-			const raw = await loadFromCode({
-				filepath,
-				code,
-				isESM,
-				cwd: this.cwd
-			}) || {};
-			this.moduleCache.set(filepath, transformRawData(raw, filepath));
-			this.updateModuleDeps(filepath, deps);
-		} catch (e) {
-			console.error(e);
-		}
-	}
 };
 
 //#endregion
-//#region src/core/mockMiddleware.ts
-function mockServerMiddleware(options, server, ws) {
-	/**
-	* 加载 mock 文件, 包括监听 mock 文件的依赖文件变化，
-	* 并注入 vite  `define` / `alias`
-	*/
-	const compiler = createMockCompiler(options);
-	compiler.run();
-	/**
-	* 监听 mock 文件是否发生变更，如何配置了 reload 为 true，
-	* 当发生变更时，通知当前页面进行重新加载
-	*/
-	compiler.on("mock:update-end", () => {
-		if (options.reload) ws?.send({ type: "full-reload" });
+//#region src/build/mockEntryCode.ts
+async function generateMockEntryCode(cwd, dir, include, exclude) {
+	const { pattern, ignore } = createMatcher(include, exclude);
+	const mockFiles = await glob(pattern, {
+		ignore,
+		cwd: path.join(cwd, dir)
 	});
-	server?.on("close", () => compiler.close());
-	/**
-	* 虽然 config.server.proxy 中有关于 ws 的代理配置，
-	* 但是由于 vite 内部在启动时，直接对 ws相关的请求，通过 upgrade 事件，发送给 http-proxy
-	* 的 ws 代理方法。如果插件直接使用 config.server.proxy 中的 ws 配置，
-	* 就会导致两次 upgrade 事件 对 wss 实例的冲突。
-	* 由于 vite 内部并没有提供其他的方式跳过 内部 upgrade 的方式，（个人认为也没有必要提供此类方式）
-	* 所以插件选择了通过插件的配置项 `wsPrefix` 来做 判断的首要条件。
-	* 当前插件默认会将已配置在 wsPrefix 的值，从 config.server.proxy 的删除，避免发生冲突问题。
-	*/
-	mockWebSocket(compiler, server, options);
-	const middlewares = [];
-	middlewares.push(
-		/**
-		* 在 vite 的开发服务中，由于插件 的 enforce 为 `pre`，
-		* mock 中间件的执行顺序 早于 vite 内部的 cors 中间件执行,
-		* 这导致了 vite 默认开启的 cors 对 mock 请求不生效。
-		* 在一些比如 微前端项目、或者联合项目中，会由于端口不一致而导致跨域问题。
-		* 所以在这里，使用 cors 中间件 来解决这个问题。
-		*
-		* 同时为了使 插件内的 cors 和 vite 的 cors 不产生冲突，并拥有一致的默认行为，
-		* 也会使用 viteConfig.server.cors 配置，并支持 用户可以对 mock 中的 cors 中间件进行配置。
-		* 而用户的配置也仅对 mock 的接口生效。
-		*/
-		corsMiddleware(compiler, options),
-		baseMiddleware(compiler, options)
-	);
-	return middlewares.filter(Boolean);
+	let importers = "";
+	const exporters = [];
+	mockFiles.forEach((filepath, index) => {
+		const file = normalizePath(path.join(cwd, dir, filepath));
+		importers += `import * as m${index} from '${file}';\n`;
+		exporters.push(`[m${index}, '${normalizePath(path.join(dir, filepath))}']`);
+	});
+	return `import { processMockData, processRawData } from 'vite-plugin-mock-dev-server/server';
+${importers}
+const exporters = [\n  ${exporters.join(",\n  ")}\n];
+const mockList = exporters.map(([mod, filepath]) => processRawData(mod.default || mod, filepath));
+export default processMockData(mockList);`;
+}
+
+//#endregion
+//#region package.json
+var name = "vite-plugin-mock-dev-server";
+var version = "1.9.3";
+
+//#endregion
+//#region src/build/packageJson.ts
+/**
+* 从 mock 文件的 importers 中获取依赖
+*/
+function getMockDependencies(deps, alias) {
+	const list = /* @__PURE__ */ new Set();
+	const excludeDeps = [
+		name,
+		"connect",
+		"cors"
+	];
+	const isAlias = (p) => alias.find(({ find }) => aliasMatches(find, p));
+	deps.forEach((dep) => {
+		const name$1 = normalizePackageName(dep);
+		if (name$1.startsWith("<define:") || isAlias(name$1) || isCore(name$1)) return;
+		if (name$1[0] === "/" || name$1.startsWith("./") || name$1.startsWith("../")) return;
+		if (!excludeDeps.includes(name$1)) list.add(name$1);
+	});
+	return Array.from(list);
+}
+function normalizePackageName(dep) {
+	const [scope, name$1] = dep.split("/");
+	if (scope[0] === "@") return `${scope}/${name$1}`;
+	return scope;
+}
+function generatePackageJson(pkg, mockDeps) {
+	const { dependencies = {}, devDependencies = {} } = pkg;
+	const dependents = {
+		...dependencies,
+		...devDependencies
+	};
+	const mockPkg = {
+		name: "mock-server",
+		type: "module",
+		scripts: { start: "node index.js" },
+		dependencies: {
+			connect: "^3.7.0",
+			[name]: `^${version}`,
+			cors: "^2.8.5"
+		},
+		pnpm: { peerDependencyRules: { ignoreMissing: ["vite"] } }
+	};
+	const ignores = [
+		"catalog:",
+		"file:",
+		"workspace:"
+	];
+	for (const dep of mockDeps) {
+		const version$1 = dependents[dep];
+		if (!version$1 || ignores.some((ignore) => version$1.startsWith(ignore))) {
+			const info = getPackageInfoSync(dep);
+			mockPkg.dependencies[dep] = info?.version ? `^${info.version}` : "latest";
+		} else mockPkg.dependencies[dep] = "latest";
+	}
+	return JSON.stringify(mockPkg, null, 2);
+}
+
+//#endregion
+//#region src/build/serverEntryCode.ts
+function generatorServerEntryCode({ proxies, wsProxies, cookiesOptions, bodyParserOptions, priority, build }) {
+	const { serverPort, log } = build;
+	return `import { createServer } from 'node:http';
+import connect from 'connect';
+import corsMiddleware from 'cors';
+import { createMockMiddleware, createLogger, mockWebSocket } from 'vite-plugin-mock-dev-server/server';
+import mockData 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(wsProxies)};
+const cookiesOptions = ${JSON.stringify(cookiesOptions)};
+const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
+const priority = ${JSON.stringify(priority)};
+const compiler = { mockData }
+
+mockWebSocket(compiler, server, { wsProxies, cookiesOptions, logger });
+
+app.use(corsMiddleware());
+app.use(createMockMiddleware(compiler, {
+  formidableOptions: { multiples: true },
+  proxies,
+  priority,
+  cookiesOptions,
+  bodyParserOptions,
+  logger,
+}));
+
+server.listen(${serverPort});
+
+console.log('listen: http://localhost:${serverPort}');
+`;
 }
-function corsMiddleware(compiler, { proxies, cors: corsOptions }) {
+
+//#endregion
+//#region src/build/generate.ts
+async function generateMockServer(ctx, options) {
+	const include = toArray(options.include);
+	const exclude = toArray(options.exclude);
+	const cwd = options.cwd || process.cwd();
+	const dir = options.dir;
+	const pkg = await loadPackageJSON(options.context) || {};
+	const outputDir = options.build.dist;
+	const content = await generateMockEntryCode(cwd, dir, include, exclude);
+	const mockEntry = path.join(cwd, `mock-data-${Date.now()}.js`);
+	await fsp.writeFile(mockEntry, content, "utf-8");
+	const { code, deps } = await transform(mockEntry, options);
+	const mockDeps = getMockDependencies(deps, options.alias);
+	await fsp.unlink(mockEntry);
+	const outputList = [
+		{
+			filename: path.join(outputDir, "mock-data.js"),
+			source: code
+		},
+		{
+			filename: path.join(outputDir, "index.js"),
+			source: generatorServerEntryCode(options)
+		},
+		{
+			filename: path.join(outputDir, "package.json"),
+			source: generatePackageJson(pkg, mockDeps)
+		}
+	];
+	try {
+		if (path.isAbsolute(outputDir)) {
+			for (const { filename } of outputList) if (fs.existsSync(filename)) await fsp.rm(filename);
+			options.logger.info(`${ansis.green("✓")} generate mock server in ${ansis.cyan(outputDir)}`);
+			for (const { filename, source } of outputList) {
+				fs.mkdirSync(path.dirname(filename), { recursive: true });
+				await fsp.writeFile(filename, source, "utf-8");
+				const sourceSize = (source.length / 1024).toFixed(2);
+				const name$1 = path.relative(outputDir, filename);
+				const space = name$1.length < 30 ? " ".repeat(30 - name$1.length) : "";
+				options.logger.info(`  ${ansis.green(name$1)}${space}${ansis.bold.dim(`${sourceSize} kB`)}`);
+			}
+		} else for (const { filename, source } of outputList) ctx.emitFile({
+			type: "asset",
+			fileName: filename,
+			source
+		});
+	} catch (e) {
+		console.error(e);
+	}
+}
+
+//#endregion
+//#region src/core/corsMiddleware.ts
+function createCorsMiddleware(compiler, { proxies, cors: corsOptions }) {
 	return !corsOptions ? void 0 : function(req, res, next) {
 		const { pathname } = urlParse(req.url);
 		if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url))) return next();
 		const mockData = compiler.mockData;
-		const mockUrl = Object.keys(mockData).find((key) => pathToRegexp(key).test(pathname));
+		const mockUrl = Object.keys(mockData).find((pattern) => isPathMatch(pattern, pathname));
 		if (!mockUrl) return next();
 		cors(corsOptions)(req, res, next);
 	};
@@ -588,17 +659,59 @@ function canJsonParse(value) {
 }
 
 //#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: build$1 = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, config) {
+//#region src/core/init.ts
+function initMockMiddlewares(options, server, ws) {
+	/**
+	* 加载 mock 文件, 包括监听 mock 文件的依赖文件变化，
+	* 并注入 vite  `define` / `alias`
+	*/
+	const compiler = new Compiler(options);
+	compiler.run(!!server);
+	/**
+	* 监听 mock 文件是否发生变更，如何配置了 reload 为 true，
+	* 当发生变更时，通知当前页面进行重新加载
+	*/
+	compiler.on("mock:update-end", () => {
+		if (options.reload) ws?.send({ type: "full-reload" });
+	});
+	server?.on("close", () => compiler.close());
+	/**
+	* 虽然 config.server.proxy 中有关于 ws 的代理配置，
+	* 但是由于 vite 内部在启动时，直接对 ws相关的请求，通过 upgrade 事件，发送给 http-proxy
+	* 的 ws 代理方法。如果插件直接使用 config.server.proxy 中的 ws 配置，
+	* 就会导致两次 upgrade 事件 对 wss 实例的冲突。
+	* 由于 vite 内部并没有提供其他的方式跳过 内部 upgrade 的方式，（个人认为也没有必要提供此类方式）
+	* 所以插件选择了通过插件的配置项 `wsPrefix` 来做 判断的首要条件。
+	* 当前插件默认会将已配置在 wsPrefix 的值，从 config.server.proxy 的删除，避免发生冲突问题。
+	*/
+	mockWebSocket(compiler, server, options);
+	const middlewares = [];
+	middlewares.push(
+		/**
+		* 在 vite 的开发服务中，由于插件 的 enforce 为 `pre`，
+		* mock 中间件的执行顺序 早于 vite 内部的 cors 中间件执行,
+		* 这导致了 vite 默认开启的 cors 对 mock 请求不生效。
+		* 在一些比如 微前端项目、或者联合项目中，会由于端口不一致而导致跨域问题。
+		* 所以在这里，使用 cors 中间件 来解决这个问题。
+		*
+		* 同时为了使 插件内的 cors 和 vite 的 cors 不产生冲突，并拥有一致的默认行为，
+		* 也会使用 viteConfig.server.cors 配置，并支持 用户可以对 mock 中的 cors 中间件进行配置。
+		* 而用户的配置也仅对 mock 的接口生效。
+		*/
+		createCorsMiddleware(compiler, options),
+		createMockMiddleware(compiler, options)
+	);
+	return middlewares.filter(Boolean);
+}
+
+//#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: cors$1 = true, formidableOptions = {}, build = false, cookiesOptions = {}, bodyParserOptions = {}, priority = {} }, config) {
 	const logger = createLogger("vite:mock", isBoolean(log) ? log ? "info" : "error" : log);
 	const { httpProxies } = ensureProxies(config.server.proxy || {});
 	const proxies = uniq([...toArray(prefix), ...httpProxies]);
 	const wsProxies = toArray(wsPrefix);
-	if (!proxies.length && !wsProxies.length) logger.warn(`No proxy was configured, mock server will not work. See ${pc.cyan("https://vite-plugin-mock-dev-server.netlify.app/guide/usage")}`);
+	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$1 === false ? false : config.server.cors !== false;
 	let corsOptions = {};
 	if (enabled && config.server.cors !== false) corsOptions = {
@@ -620,6 +733,7 @@ function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["moc
 	});
 	return {
 		cwd: cwd || process.cwd(),
+		dir,
 		include,
 		exclude,
 		context: config.root,
@@ -633,11 +747,12 @@ function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["moc
 		},
 		bodyParserOptions,
 		priority,
-		build: build$1 ? Object.assign({
+		build: build ? {
 			serverPort: 8080,
 			dist: "mockServer",
-			log: "error"
-		}, typeof build$1 === "object" ? build$1 : {}) : false,
+			log: "error",
+			...typeof build === "object" ? build : {}
+		} : false,
 		proxies,
 		wsProxies,
 		logger,
@@ -645,6 +760,19 @@ function resolvePluginOptions({ prefix = [], wsPrefix = [], cwd, include = ["moc
 		define: viteDefine(config)
 	};
 }
+function ensureProxies(serverProxy = {}) {
+	const httpProxies = [];
+	const wsProxies = [];
+	Object.keys(serverProxy).forEach((key) => {
+		const value = serverProxy[key];
+		if (typeof value === "string" || !value.ws && !value.target?.toString().startsWith("ws:") && !value.target?.toString().startsWith("wss:")) httpProxies.push(key);
+		else wsProxies.push(key);
+	});
+	return {
+		httpProxies,
+		wsProxies
+	};
+}
 
 //#endregion
 //#region src/plugin.ts
@@ -693,25 +821,15 @@ function serverPlugin(options) {
 			config.logger.warn("");
 		},
 		configureServer({ middlewares, httpServer, ws }) {
-			const middlewareList = mockServerMiddleware(resolvedOptions, httpServer, ws);
+			const middlewareList = initMockMiddlewares(resolvedOptions, httpServer, ws);
 			middlewareList.forEach((middleware) => middlewares.use(middleware));
 		},
 		configurePreviewServer({ middlewares, httpServer }) {
-			const middlewareList = mockServerMiddleware(resolvedOptions, httpServer);
+			const middlewareList = initMockMiddlewares(resolvedOptions, httpServer);
 			middlewareList.forEach((middleware) => middlewares.use(middleware));
 		}
 	};
 }
 
 //#endregion
-//#region src/index.ts
-/**
-* @deprecated use named export instead
-*/
-function mockDevServerPluginWithDefaultExportWasDeprecated(options = {}) {
-	console.warn(`${pc.yellow("[vite-plugin-mock-dev-server]")} ${pc.yellow(pc.bold("WARNING:"))} The plugin default export is ${pc.bold("deprecated")}, it will be removed in next major version, use ${pc.bold("named export")} instead:\n\n    ${pc.green("import { mockDevServerPlugin } from \"vite-plugin-mock-dev-server\"")}\n`);
-	return mockDevServerPlugin(options);
-}
-
-//#endregion
-export { baseMiddleware, createDefineMock, createLogger, createSSEStream, mockDevServerPluginWithDefaultExportWasDeprecated as default, defineMock, defineMockData, logLevels, mockDevServerPlugin, mockWebSocket, sortByValidator, transformMockData, transformRawData };
+export { createDefineMock, createLogger, createMockMiddleware, createSSEStream, defineMock, defineMockData, logLevels, mockDevServerPlugin, mockWebSocket, processMockData, processRawData, sortByValidator };