vite-plugin-mock-dev-server 0.3.16 → 0.3.18

package/dist/index.cjs

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -26,31 +26,70 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  baseMiddleware: () => baseMiddleware,
   default: () => src_default,
   defineMock: () => defineMock,
   mockDevServerPlugin: () => mockDevServerPlugin
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/mockMiddleware.ts
-var import_node_url3 = require("url");
-var import_path_to_regexp = require("path-to-regexp");
-
-// src/MockLoader.ts
-var import_node_events = __toESM(require("events"), 1);
+// src/build.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_module = require("module");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
-var import_chokidar = __toESM(require("chokidar"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_esbuild = require("esbuild");
 var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_json5 = __toESM(require("json5"), 1);
+var import_is_core_module = __toESM(require("is-core-module"), 1);
 var import_vite = require("vite");
 
+// package.json
+var name = "vite-plugin-mock-dev-server";
+var version = "0.3.18";
+
+// src/esbuildPlugin.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_json5 = __toESM(require("json5"), 1);
+var externalizeDeps = {
+  name: "externalize-deps",
+  setup(build3) {
+    build3.onResolve({ filter: /.*/ }, ({ path: id }) => {
+      if (id[0] !== "." && !import_node_path.default.isAbsolute(id)) {
+        return {
+          external: true
+        };
+      }
+    });
+  }
+};
+var json5Loader = {
+  name: "json5-loader",
+  setup(build3) {
+    build3.onLoad({ filter: /\.json5$/ }, async ({ path: path5 }) => {
+      const content = await import_promises.default.readFile(path5, "utf-8");
+      return {
+        contents: `export default ${JSON.stringify(import_json5.default.parse(content))}`,
+        loader: "js"
+      };
+    });
+  }
+};
+var jsonLoader = {
+  name: "json-loader",
+  setup(build3) {
+    build3.onLoad({ filter: /\.json$/ }, async ({ path: path5 }) => {
+      const content = await import_promises.default.readFile(path5, "utf-8");
+      return {
+        contents: `export default ${content}`,
+        loader: "js"
+      };
+    });
+  }
+};
+
 // src/utils.ts
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_debug = __toESM(require("debug"), 1);
 var isArray = (val) => Array.isArray(val);
@@ -59,12 +98,12 @@ function sleep(timeout) {
   return new Promise((resolve) => setTimeout(resolve, timeout));
 }
 function getDirname(importMetaUrl) {
-  return import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 }
 var debug = (0, import_debug.default)("vite:plugin-mock-dev-server");
 function lookupFile(dir, formats, options) {
   for (const format of formats) {
-    const fullPath = import_node_path.default.join(dir, format);
+    const fullPath = import_node_path2.default.join(dir, format);
     if (import_node_fs.default.existsSync(fullPath) && import_node_fs.default.statSync(fullPath).isFile()) {
       const result = (options == null ? void 0 : options.pathOnly) ? fullPath : import_node_fs.default.readFileSync(fullPath, "utf-8");
       if (!(options == null ? void 0 : options.predicate) || options.predicate(result)) {
@@ -72,13 +111,355 @@ function lookupFile(dir, formats, options) {
       }
     }
   }
-  const parentDir = import_node_path.default.dirname(dir);
+  const parentDir = import_node_path2.default.dirname(dir);
   if (parentDir !== dir && (!(options == null ? void 0 : options.rootDir) || parentDir.startsWith(options == null ? void 0 : options.rootDir))) {
     return lookupFile(parentDir, formats, options);
   }
 }
 
+// src/build.ts
+async function generateMockServer(ctx, config, options) {
+  const include = isArray(options.include) ? options.include : [options.include];
+  const exclude = isArray(options.exclude) ? options.exclude : [options.exclude];
+  const define = {};
+  if (config.define) {
+    for (const key in config.define) {
+      const val = config.define[key];
+      define[key] = typeof val === "string" ? val : JSON.stringify(val);
+    }
+  }
+  let pkg = {};
+  try {
+    const pkgStr = lookupFile(config.root, ["package.json"]);
+    if (pkgStr) {
+      pkg = JSON.parse(pkgStr);
+    }
+  } catch {
+  }
+  const outputDir = options.build.dist;
+  const content = await generateMockEntryCode(process.cwd(), include, exclude);
+  const mockEntry = import_node_path3.default.join(config.root, `mock-data-${Date.now()}.js`);
+  await import_promises2.default.writeFile(mockEntry, content, "utf-8");
+  const { code, deps } = await buildMockEntry(mockEntry, define);
+  const mockDeps = getMockDependencies(deps);
+  await import_promises2.default.unlink(mockEntry);
+  const outputList = [
+    {
+      filename: import_node_path3.default.join(outputDir, "mock-data.js"),
+      source: code
+    },
+    {
+      filename: import_node_path3.default.join(outputDir, "index.js"),
+      source: generatorServerEntryCode(
+        config.server.proxy || {},
+        options.build.serverPort
+      )
+    },
+    {
+      filename: import_node_path3.default.join(outputDir, "package.json"),
+      source: generatePackageJson(pkg, mockDeps)
+    }
+  ];
+  try {
+    if (import_node_path3.default.isAbsolute(outputDir)) {
+      await import_promises2.default.rm(outputDir, { recursive: true });
+      import_node_fs2.default.mkdirSync(outputDir, { recursive: true });
+      for (const { filename, source } of outputList) {
+        await import_promises2.default.writeFile(filename, source, "utf-8");
+      }
+    } else {
+      for (const { filename, source } of outputList) {
+        ctx.emitFile({
+          type: "asset",
+          fileName: filename,
+          source
+        });
+      }
+    }
+  } catch {
+  }
+}
+function getMockDependencies(deps) {
+  const list = /* @__PURE__ */ new Set();
+  const excludeDeps = [name, "connect"];
+  Object.keys(deps).forEach((mPath) => {
+    const imports = deps[mPath].imports.filter((_) => _.external).map((_) => _.path);
+    imports.forEach((dep) => {
+      if (!excludeDeps.includes(dep) && !(0, import_is_core_module.default)(dep)) {
+        list.add(dep);
+      }
+    });
+  });
+  return Array.from(list);
+}
+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": `^${version}`
+    }
+  };
+  mockDeps.forEach((dep) => {
+    mockPkg.dependencies[dep] = dependents[dep] || "latest";
+  });
+  return JSON.stringify(mockPkg, null, 2);
+}
+function generatorServerEntryCode(proxy = {}, port = 8080) {
+  const proxies = Object.keys(proxy || {});
+  return `import connect from 'connect'
+import { baseMiddleware } from 'vite-plugin-mock-dev-server'
+import mockData from './mock-data.js'
+const app = connect()
+app.use(baseMiddleware(mockData, {
+  formidableOptions: { multiples: true },
+  proxies: ${JSON.stringify(proxies)} 
+}))
+app.listen(${port})
+console.log('listen: http://localhost:${port}')
+`;
+}
+async function generateMockEntryCode(cwd, include, exclude) {
+  const includePaths = await (0, import_fast_glob.default)(include, { cwd });
+  const includeFilter = (0, import_vite.createFilter)(include, exclude, {
+    resolve: false
+  });
+  const mockFiles = includePaths.filter(includeFilter);
+  let importers = "";
+  let exporters = "";
+  mockFiles.forEach((filepath, index) => {
+    const file = import_node_path3.default.join(cwd, filepath);
+    importers += `import * as m${index} from '${file}'
+`;
+    exporters += `m${index}, `;
+  });
+  return `${importers}const mockData = [${exporters}];
+
+const data = [];
+const mocks = {};
+mockData.forEach(mock => {
+  Object.keys(mock).forEach(key => {
+    const mockData = mock[key];
+    if (Array.isArray(mockData)) {
+      data.push(...mockData);
+    } else {
+      if (typeof mockData === 'object' && Object.prototype.hasOwnProperty.call(mockData, 'url')) {
+        data.push(mockData);
+      }
+    }
+  })
+})
+data
+  .filter((mock) => mock.enabled || typeof mock.enabled === "undefined")
+  .forEach((mock) => {
+    if (!mocks[mock.url]) {
+      mocks[mock.url] = [];
+    }
+    const list = mocks[mock.url];
+    mock.validator ? list.unshift(mock) : list.push(mock);
+  });
+export default mocks;
+  `;
+}
+async function buildMockEntry(inputFile, define) {
+  var _a;
+  try {
+    const result = await (0, import_esbuild.build)({
+      entryPoints: [inputFile],
+      outfile: "out.js",
+      write: false,
+      target: ["node14.18", "node16"],
+      platform: "node",
+      bundle: true,
+      metafile: true,
+      format: "esm",
+      define,
+      plugins: [externalizeDeps, json5Loader, jsonLoader]
+    });
+    return {
+      code: result.outputFiles[0].text,
+      deps: ((_a = result.metafile) == null ? void 0 : _a.inputs) || {}
+    };
+  } catch (e) {
+    console.error(e);
+  }
+  return { code: "", deps: {} };
+}
+
+// src/baseMiddleware.ts
+var import_node_url2 = require("url");
+var import_path_to_regexp = require("path-to-regexp");
+
+// src/parseReqBody.ts
+var import_co_body = __toESM(require("co-body"), 1);
+var import_formidable = __toESM(require("formidable"), 1);
+async function parseReqBody(req, options) {
+  const method = req.method.toUpperCase();
+  if (["GET", "DELETE", "HEAD"].includes(method))
+    return void 0;
+  const type = req.headers["content-type"];
+  try {
+    if (type === "application/json") {
+      return await import_co_body.default.json(req);
+    }
+    if (type === "application/x-www-form-urlencoded") {
+      return await import_co_body.default.form(req);
+    }
+    if (type === "text/plain") {
+      return await import_co_body.default.text(req);
+    }
+    if (type == null ? void 0 : type.startsWith("multipart/form-data;")) {
+      return await parseMultipart(req, options);
+    }
+  } catch (e) {
+    console.error(e);
+  }
+  return void 0;
+}
+async function parseMultipart(req, options) {
+  const form = (0, import_formidable.default)(options);
+  return new Promise((resolve, reject) => {
+    form.parse(req, (error, fields, files) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ ...fields, ...files });
+    });
+  });
+}
+
+// src/validator.ts
+function validate(request, validator) {
+  return equalObj(request.headers, validator.headers) && equalObj(request.body, validator.body) && equalObj(request.params, validator.params) && equalObj(request.query, validator.query);
+}
+function equalObj(left, right) {
+  if (!right)
+    return true;
+  for (const key in right) {
+    if (right[key] !== left[key])
+      return false;
+  }
+  return true;
+}
+
+// src/baseMiddleware.ts
+function baseMiddleware(mockData, { formidableOptions = {}, proxies }) {
+  return async function(req, res, next) {
+    const method = req.method.toUpperCase();
+    const { query, pathname } = (0, import_node_url2.parse)(req.url, true);
+    if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url))) {
+      return next();
+    }
+    const mockUrl = Object.keys(mockData).find((key) => {
+      return (0, import_path_to_regexp.pathToRegexp)(key).test(pathname);
+    });
+    if (!mockUrl) {
+      return next();
+    }
+    const mockList = mockData[mockUrl];
+    const reqBody = await parseReqBody(req, formidableOptions);
+    const currentMock = mockList.find((mock) => {
+      if (!pathname || !mock || !mock.url)
+        return false;
+      const methods = mock.method ? isArray(mock.method) ? mock.method : [mock.method] : ["GET", "POST"];
+      if (!methods.includes(req.method.toUpperCase()))
+        return false;
+      const hasMock = (0, import_path_to_regexp.pathToRegexp)(mock.url).test(pathname);
+      if (hasMock && mock.validator) {
+        const urlMatch2 = (0, import_path_to_regexp.match)(mock.url, { decode: decodeURIComponent })(
+          pathname
+        ) || { params: {} };
+        const params2 = urlMatch2.params || {};
+        const request = {
+          query,
+          params: params2,
+          body: reqBody,
+          headers: req.headers
+        };
+        if (isFunction(mock.validator)) {
+          return mock.validator(request);
+        } else {
+          return validate(request, mock.validator);
+        }
+      }
+      return hasMock;
+    });
+    if (!currentMock)
+      return next();
+    debug("middleware: ", method, pathname);
+    if (currentMock.delay && currentMock.delay > 0) {
+      await sleep(currentMock.delay);
+    }
+    res.statusCode = currentMock.status || 200;
+    res.statusMessage = currentMock.statusText || "OK";
+    const urlMatch = (0, import_path_to_regexp.match)(currentMock.url, { decode: decodeURIComponent })(
+      pathname
+    ) || { params: {} };
+    const params = urlMatch.params || {};
+    req.body = reqBody;
+    req.query = query;
+    req.params = params;
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("X-Mock", "generate by vite:mock-dev-server");
+    if (currentMock.headers) {
+      const headers = isFunction(currentMock.headers) ? await currentMock.headers({
+        query,
+        body: reqBody,
+        params,
+        headers: req.headers
+      }) : currentMock.headers;
+      Object.keys(headers).forEach((key) => {
+        res.setHeader(key, headers[key]);
+      });
+    }
+    if (currentMock.body) {
+      let body;
+      if (isFunction(currentMock.body)) {
+        body = await currentMock.body({
+          query,
+          body: reqBody,
+          params,
+          headers: req.headers
+        });
+      } else {
+        body = currentMock.body;
+      }
+      res.end(JSON.stringify(body));
+      return;
+    }
+    if (currentMock.response) {
+      await currentMock.response(
+        req,
+        res,
+        next
+      );
+      return;
+    }
+    res.end("");
+  };
+}
+function doesProxyContextMatchUrl(context, url) {
+  return context.startsWith("^") && new RegExp(context).test(url) || url.startsWith(context);
+}
+
 // src/MockLoader.ts
+var import_node_events = __toESM(require("events"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_esbuild2 = require("esbuild");
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_json52 = __toESM(require("json5"), 1);
+var import_vite2 = require("vite");
 var import_meta = {};
 var _dirname = typeof __dirname !== "undefined" ? __dirname : getDirname(import_meta.url);
 var _require = (0, import_node_module.createRequire)(_dirname);
@@ -88,8 +469,8 @@ var _MockLoader = class extends import_node_events.default {
     this.options = options;
     this.moduleCache = /* @__PURE__ */ new Map();
     this.moduleDeps = /* @__PURE__ */ new Map();
-    this._mockList = {};
     this.moduleType = "cjs";
+    this._mockData = {};
     this.cwd = options.cwd || process.cwd();
     try {
       const pkg = lookupFile(this.cwd, ["package.json"]);
@@ -97,15 +478,15 @@ var _MockLoader = class extends import_node_events.default {
     } catch (e) {
     }
   }
-  get mockList() {
-    return this._mockList;
+  get mockData() {
+    return this._mockData;
   }
   async load() {
     const { include, exclude } = this.options;
-    const includePaths = await (0, import_fast_glob.default)(include, {
+    const includePaths = await (0, import_fast_glob2.default)(include, {
       cwd: this.cwd
     });
-    const includeFilter = (0, import_vite.createFilter)(include, exclude, {
+    const includeFilter = (0, import_vite2.createFilter)(include, exclude, {
       resolve: false
     });
     this.watchMockEntry();
@@ -191,7 +572,7 @@ var _MockLoader = class extends import_node_events.default {
       const list = mocks[mock.url];
       mock.validator ? list.unshift(mock) : list.push(mock);
     });
-    this._mockList = mocks;
+    this._mockData = mocks;
   }
   updateModuleDeps(filepath, deps) {
     Object.keys(deps).forEach((mPath) => {
@@ -216,9 +597,9 @@ var _MockLoader = class extends import_node_events.default {
     }
   }
   async loadJson(filepath) {
-    const content = await import_node_fs2.default.promises.readFile(filepath, "utf-8");
+    const content = await import_node_fs3.default.promises.readFile(filepath, "utf-8");
     try {
-      const mockConfig = import_json5.default.parse(content);
+      const mockConfig = import_json52.default.parse(content);
       this.moduleCache.set(filepath, mockConfig);
     } catch (e) {
     }
@@ -248,20 +629,20 @@ var _MockLoader = class extends import_node_events.default {
     if (isESM) {
       const fileBase = `${filepath}.timestamp-${Date.now()}`;
       const fileNameTmp = `${fileBase}.mjs`;
-      const fileUrl = `${(0, import_node_url2.pathToFileURL)(fileBase)}.mjs`;
-      await import_node_fs2.default.promises.writeFile(fileNameTmp, code, "utf8");
+      const fileUrl = `${(0, import_node_url3.pathToFileURL)(fileBase)}.mjs`;
+      await import_node_fs3.default.promises.writeFile(fileNameTmp, code, "utf8");
       try {
         return await import(fileUrl);
       } finally {
         try {
-          import_node_fs2.default.unlinkSync(fileNameTmp);
+          import_node_fs3.default.unlinkSync(fileNameTmp);
         } catch {
         }
       }
     } else {
-      filepath = import_node_path2.default.resolve(this.cwd, filepath);
-      const extension = import_node_path2.default.extname(filepath);
-      const realFileName = import_node_fs2.default.realpathSync(filepath);
+      filepath = import_node_path4.default.resolve(this.cwd, filepath);
+      const extension = import_node_path4.default.extname(filepath);
+      const realFileName = import_node_fs3.default.realpathSync(filepath);
       const loaderExt = extension in _require.extensions ? extension : ".js";
       const defaultLoader = _require.extensions[loaderExt];
       _require.extensions[loaderExt] = (module2, filename) => {
@@ -281,7 +662,7 @@ var _MockLoader = class extends import_node_events.default {
   async transformWithEsbuild(filepath, isESM) {
     var _a;
     try {
-      const result = await (0, import_esbuild.build)({
+      const result = await (0, import_esbuild2.build)({
         entryPoints: [filepath],
         outfile: "out.js",
         write: false,
@@ -291,20 +672,7 @@ var _MockLoader = class extends import_node_events.default {
         metafile: true,
         format: isESM ? "esm" : "cjs",
         define: this.options.define,
-        plugins: [
-          {
-            name: "externalize-deps",
-            setup(build2) {
-              build2.onResolve({ filter: /.*/ }, ({ path: id }) => {
-                if (id[0] !== "." && !import_node_path2.default.isAbsolute(id)) {
-                  return {
-                    external: true
-                  };
-                }
-              });
-            }
-          }
-        ]
+        plugins: [externalizeDeps]
       });
       return {
         code: result.outputFiles[0].text,
@@ -321,59 +689,6 @@ var _MockLoader = class extends import_node_events.default {
 var MockLoader = _MockLoader;
 MockLoader.EXT_JSON = /\.json5?$/;
 
-// src/parseReqBody.ts
-var import_co_body = __toESM(require("co-body"), 1);
-var import_formidable = __toESM(require("formidable"), 1);
-async function parseReqBody(req, options) {
-  const method = req.method.toUpperCase();
-  if (["GET", "DELETE", "HEAD"].includes(method))
-    return void 0;
-  const type = req.headers["content-type"];
-  try {
-    if (type === "application/json") {
-      return await import_co_body.default.json(req);
-    }
-    if (type === "application/x-www-form-urlencoded") {
-      return await import_co_body.default.form(req);
-    }
-    if (type === "text/plain") {
-      return await import_co_body.default.text(req);
-    }
-    if (type == null ? void 0 : type.startsWith("multipart/form-data;")) {
-      return await parseMultipart(req, options);
-    }
-  } catch (e) {
-    console.error(e);
-  }
-  return void 0;
-}
-async function parseMultipart(req, options) {
-  const form = (0, import_formidable.default)(options);
-  return new Promise((resolve, reject) => {
-    form.parse(req, (error, fields, files) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve({ ...fields, ...files });
-    });
-  });
-}
-
-// src/validator.ts
-function validate(request, validator) {
-  return equalObj(request.headers, validator.headers) && equalObj(request.body, validator.body) && equalObj(request.params, validator.params) && equalObj(request.query, validator.query);
-}
-function equalObj(left, right) {
-  if (!right)
-    return true;
-  for (const key in right) {
-    if (right[key] !== left[key])
-      return false;
-  }
-  return true;
-}
-
 // src/mockMiddleware.ts
 async function mockServerMiddleware(httpServer, config, options) {
   const include = isArray(options.include) ? options.include : [options.include];
@@ -393,106 +708,13 @@ async function mockServerMiddleware(httpServer, config, options) {
   await loader.load();
   httpServer == null ? void 0 : httpServer.on("close", () => loader.close());
   const proxies = Object.keys(config.server.proxy || {});
-  return async function(req, res, next) {
-    const method = req.method.toUpperCase();
-    const { query, pathname } = (0, import_node_url3.parse)(req.url, true);
-    if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url))) {
-      return next();
-    }
-    const mockUrl = Object.keys(loader._mockList).find((key) => {
-      return (0, import_path_to_regexp.pathToRegexp)(key).test(pathname);
-    });
-    if (!mockUrl) {
-      return next();
-    }
-    const mockList = loader.mockList[mockUrl];
-    const reqBody = await parseReqBody(req, options.formidableOptions);
-    const currentMock = mockList.find((mock) => {
-      if (!pathname || !mock || !mock.url)
-        return false;
-      const methods = mock.method ? isArray(mock.method) ? mock.method : [mock.method] : ["GET", "POST"];
-      if (!methods.includes(req.method.toUpperCase()))
-        return false;
-      const hasMock = (0, import_path_to_regexp.pathToRegexp)(mock.url).test(pathname);
-      if (hasMock && mock.validator) {
-        const urlMatch2 = (0, import_path_to_regexp.match)(mock.url, { decode: decodeURIComponent })(
-          pathname
-        ) || { params: {} };
-        const params2 = urlMatch2.params || {};
-        const request = {
-          query,
-          params: params2,
-          body: reqBody,
-          headers: req.headers
-        };
-        if (isFunction(mock.validator)) {
-          return mock.validator(request);
-        } else {
-          return validate(request, mock.validator);
-        }
-      }
-      return hasMock;
-    });
-    if (!currentMock)
-      return next();
-    debug("middleware: ", method, pathname);
-    if (currentMock.delay && currentMock.delay > 0) {
-      await sleep(currentMock.delay);
-    }
-    res.statusCode = currentMock.status || 200;
-    res.statusMessage = currentMock.statusText || "OK";
-    const urlMatch = (0, import_path_to_regexp.match)(currentMock.url, { decode: decodeURIComponent })(
-      pathname
-    ) || { params: {} };
-    const params = urlMatch.params || {};
-    req.body = reqBody;
-    req.query = query;
-    req.params = params;
-    res.setHeader("Content-Type", "application/json");
-    res.setHeader("X-Mock", "generate by vite:mock-dev-server");
-    if (currentMock.headers) {
-      const headers = isFunction(currentMock.headers) ? await currentMock.headers({
-        query,
-        body: reqBody,
-        params,
-        headers: req.headers
-      }) : currentMock.headers;
-      Object.keys(headers).forEach((key) => {
-        res.setHeader(key, headers[key]);
-      });
-    }
-    if (currentMock.body) {
-      let body;
-      if (isFunction(currentMock.body)) {
-        body = await currentMock.body({
-          query,
-          body: reqBody,
-          params,
-          headers: req.headers
-        });
-      } else {
-        body = currentMock.body;
-      }
-      res.end(JSON.stringify(body));
-      return;
-    }
-    if (currentMock.response) {
-      await currentMock.response(
-        req,
-        res,
-        next
-      );
-      return;
-    }
-    res.end("");
-  };
-}
-function doesProxyContextMatchUrl(context, url) {
-  return context.startsWith("^") && new RegExp(context).test(url) || url.startsWith(context);
+  return baseMiddleware(loader.mockData, {
+    formidableOptions: options.formidableOptions,
+    proxies
+  });
 }
 
 // src/plugin.ts
-var viteConfig = {};
 function mockDevServerPlugin({
   include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"],
   exclude = [
@@ -503,8 +725,51 @@ function mockDevServerPlugin({
     "**/.git/**",
     "**/dist/**"
   ],
-  formidableOptions = {}
+  formidableOptions = {},
+  build: build3 = false
 } = {}) {
+  const pluginOptions = {
+    include,
+    exclude,
+    formidableOptions: {
+      multiples: true,
+      ...formidableOptions
+    },
+    build: build3 ? Object.assign(
+      {
+        serverPort: 8080,
+        dist: "mockServer"
+      },
+      typeof build3 === "object" ? build3 : {}
+    ) : false
+  };
+  const plugins = [serverPlugin(pluginOptions)];
+  if (pluginOptions.build) {
+    plugins.push(buildPlugin(pluginOptions));
+  }
+  return plugins;
+}
+function buildPlugin(pluginOptions) {
+  let viteConfig = {};
+  return {
+    name: "vite-plugin-mock-dev-server-generator",
+    enforce: "post",
+    apply: "build",
+    configResolved(config) {
+      viteConfig = config;
+      config.logger.warn("");
+    },
+    async buildEnd(error) {
+      if (error)
+        return;
+      if (viteConfig.command !== "build")
+        return;
+      await generateMockServer(this, viteConfig, pluginOptions);
+    }
+  };
+}
+function serverPlugin(pluginOptions) {
+  let viteConfig = {};
   return {
     name: "vite-plugin-mock-dev-server",
     enforce: "pre",
@@ -514,25 +779,19 @@ function mockDevServerPlugin({
       config.logger.warn("");
     },
     async configureServer({ middlewares, config, httpServer }) {
-      const middleware = await mockServerMiddleware(httpServer, config, {
-        include,
-        exclude,
-        formidableOptions: {
-          multiples: true,
-          ...formidableOptions
-        }
-      });
+      const middleware = await mockServerMiddleware(
+        httpServer,
+        config,
+        pluginOptions
+      );
       middlewares.use(middleware);
     },
     async configurePreviewServer({ middlewares, httpServer }) {
-      const middleware = await mockServerMiddleware(httpServer, viteConfig, {
-        include,
-        exclude,
-        formidableOptions: {
-          multiples: true,
-          ...formidableOptions
-        }
-      });
+      const middleware = await mockServerMiddleware(
+        httpServer,
+        viteConfig,
+        pluginOptions
+      );
       middlewares.use(middleware);
     }
   };
@@ -547,6 +806,7 @@ function defineMock(config) {
 var src_default = mockDevServerPlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  baseMiddleware,
   defineMock,
   mockDevServerPlugin
 });