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

package/dist/index.js

@@ -1,22 +1,60 @@
-// src/mockMiddleware.ts
-import { parse as urlParse } from "url";
-import { match, pathToRegexp } from "path-to-regexp";
-
-// src/MockLoader.ts
-import EventEmitter from "events";
+// src/build.ts
 import fs2 from "fs";
-import { createRequire } from "module";
-import path2 from "path";
-import { pathToFileURL } from "url";
-import chokidar from "chokidar";
+import fsp2 from "fs/promises";
+import path3 from "path";
 import { build } from "esbuild";
-import fastGlob from "fast-glob";
-import JSON5 from "json5";
+import fg from "fast-glob";
+import isCore from "is-core-module";
 import { createFilter } from "vite";
 
+// package.json
+var name = "vite-plugin-mock-dev-server";
+var version = "0.3.18";
+
+// src/esbuildPlugin.ts
+import fsp from "fs/promises";
+import path from "path";
+import JSON5 from "json5";
+var externalizeDeps = {
+  name: "externalize-deps",
+  setup(build3) {
+    build3.onResolve({ filter: /.*/ }, ({ path: id }) => {
+      if (id[0] !== "." && !path.isAbsolute(id)) {
+        return {
+          external: true
+        };
+      }
+    });
+  }
+};
+var json5Loader = {
+  name: "json5-loader",
+  setup(build3) {
+    build3.onLoad({ filter: /\.json5$/ }, async ({ path: path5 }) => {
+      const content = await fsp.readFile(path5, "utf-8");
+      return {
+        contents: `export default ${JSON.stringify(JSON5.parse(content))}`,
+        loader: "js"
+      };
+    });
+  }
+};
+var jsonLoader = {
+  name: "json-loader",
+  setup(build3) {
+    build3.onLoad({ filter: /\.json$/ }, async ({ path: path5 }) => {
+      const content = await fsp.readFile(path5, "utf-8");
+      return {
+        contents: `export default ${content}`,
+        loader: "js"
+      };
+    });
+  }
+};
+
 // src/utils.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import { fileURLToPath } from "url";
 import Debug from "debug";
 var isArray = (val) => Array.isArray(val);
@@ -25,12 +63,12 @@ function sleep(timeout) {
   return new Promise((resolve) => setTimeout(resolve, timeout));
 }
 function getDirname(importMetaUrl) {
-  return path.dirname(fileURLToPath(importMetaUrl));
+  return path2.dirname(fileURLToPath(importMetaUrl));
 }
 var debug = Debug("vite:plugin-mock-dev-server");
 function lookupFile(dir, formats, options) {
   for (const format of formats) {
-    const fullPath = path.join(dir, format);
+    const fullPath = path2.join(dir, format);
     if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
       const result = (options == null ? void 0 : options.pathOnly) ? fullPath : fs.readFileSync(fullPath, "utf-8");
       if (!(options == null ? void 0 : options.predicate) || options.predicate(result)) {
@@ -38,13 +76,355 @@ function lookupFile(dir, formats, options) {
       }
     }
   }
-  const parentDir = path.dirname(dir);
+  const parentDir = path2.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 = path3.join(config.root, `mock-data-${Date.now()}.js`);
+  await fsp2.writeFile(mockEntry, content, "utf-8");
+  const { code, deps } = await buildMockEntry(mockEntry, define);
+  const mockDeps = getMockDependencies(deps);
+  await fsp2.unlink(mockEntry);
+  const outputList = [
+    {
+      filename: path3.join(outputDir, "mock-data.js"),
+      source: code
+    },
+    {
+      filename: path3.join(outputDir, "index.js"),
+      source: generatorServerEntryCode(
+        config.server.proxy || {},
+        options.build.serverPort
+      )
+    },
+    {
+      filename: path3.join(outputDir, "package.json"),
+      source: generatePackageJson(pkg, mockDeps)
+    }
+  ];
+  try {
+    if (path3.isAbsolute(outputDir)) {
+      await fsp2.rm(outputDir, { recursive: true });
+      fs2.mkdirSync(outputDir, { recursive: true });
+      for (const { filename, source } of outputList) {
+        await fsp2.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) && !isCore(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 fg(include, { cwd });
+  const includeFilter = createFilter(include, exclude, {
+    resolve: false
+  });
+  const mockFiles = includePaths.filter(includeFilter);
+  let importers = "";
+  let exporters = "";
+  mockFiles.forEach((filepath, index) => {
+    const file = path3.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 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
+import { parse as urlParse } from "url";
+import { match, pathToRegexp } from "path-to-regexp";
+
+// src/parseReqBody.ts
+import bodyParser from "co-body";
+import formidable from "formidable";
+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 bodyParser.json(req);
+    }
+    if (type === "application/x-www-form-urlencoded") {
+      return await bodyParser.form(req);
+    }
+    if (type === "text/plain") {
+      return await bodyParser.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 = formidable(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 } = urlParse(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 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 = pathToRegexp(mock.url).test(pathname);
+      if (hasMock && mock.validator) {
+        const urlMatch2 = 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 = 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
+import EventEmitter from "events";
+import fs3 from "fs";
+import { createRequire } from "module";
+import path4 from "path";
+import { pathToFileURL } from "url";
+import chokidar from "chokidar";
+import { build as build2 } from "esbuild";
+import fastGlob from "fast-glob";
+import JSON52 from "json5";
+import { createFilter as createFilter2 } from "vite";
 var _dirname = typeof __dirname !== "undefined" ? __dirname : getDirname(import.meta.url);
 var _require = createRequire(_dirname);
 var _MockLoader = class extends EventEmitter {
@@ -53,8 +433,8 @@ var _MockLoader = class extends EventEmitter {
     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"]);
@@ -62,15 +442,15 @@ var _MockLoader = class extends EventEmitter {
     } catch (e) {
     }
   }
-  get mockList() {
-    return this._mockList;
+  get mockData() {
+    return this._mockData;
   }
   async load() {
     const { include, exclude } = this.options;
     const includePaths = await fastGlob(include, {
       cwd: this.cwd
     });
-    const includeFilter = createFilter(include, exclude, {
+    const includeFilter = createFilter2(include, exclude, {
       resolve: false
     });
     this.watchMockEntry();
@@ -156,7 +536,7 @@ var _MockLoader = class extends EventEmitter {
       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) => {
@@ -181,9 +561,9 @@ var _MockLoader = class extends EventEmitter {
     }
   }
   async loadJson(filepath) {
-    const content = await fs2.promises.readFile(filepath, "utf-8");
+    const content = await fs3.promises.readFile(filepath, "utf-8");
     try {
-      const mockConfig = JSON5.parse(content);
+      const mockConfig = JSON52.parse(content);
       this.moduleCache.set(filepath, mockConfig);
     } catch (e) {
     }
@@ -214,19 +594,19 @@ var _MockLoader = class extends EventEmitter {
       const fileBase = `${filepath}.timestamp-${Date.now()}`;
       const fileNameTmp = `${fileBase}.mjs`;
       const fileUrl = `${pathToFileURL(fileBase)}.mjs`;
-      await fs2.promises.writeFile(fileNameTmp, code, "utf8");
+      await fs3.promises.writeFile(fileNameTmp, code, "utf8");
       try {
         return await import(fileUrl);
       } finally {
         try {
-          fs2.unlinkSync(fileNameTmp);
+          fs3.unlinkSync(fileNameTmp);
         } catch {
         }
       }
     } else {
-      filepath = path2.resolve(this.cwd, filepath);
-      const extension = path2.extname(filepath);
-      const realFileName = fs2.realpathSync(filepath);
+      filepath = path4.resolve(this.cwd, filepath);
+      const extension = path4.extname(filepath);
+      const realFileName = fs3.realpathSync(filepath);
       const loaderExt = extension in _require.extensions ? extension : ".js";
       const defaultLoader = _require.extensions[loaderExt];
       _require.extensions[loaderExt] = (module, filename) => {
@@ -246,7 +626,7 @@ var _MockLoader = class extends EventEmitter {
   async transformWithEsbuild(filepath, isESM) {
     var _a;
     try {
-      const result = await build({
+      const result = await build2({
         entryPoints: [filepath],
         outfile: "out.js",
         write: false,
@@ -256,20 +636,7 @@ var _MockLoader = class extends EventEmitter {
         metafile: true,
         format: isESM ? "esm" : "cjs",
         define: this.options.define,
-        plugins: [
-          {
-            name: "externalize-deps",
-            setup(build2) {
-              build2.onResolve({ filter: /.*/ }, ({ path: id }) => {
-                if (id[0] !== "." && !path2.isAbsolute(id)) {
-                  return {
-                    external: true
-                  };
-                }
-              });
-            }
-          }
-        ]
+        plugins: [externalizeDeps]
       });
       return {
         code: result.outputFiles[0].text,
@@ -286,59 +653,6 @@ var _MockLoader = class extends EventEmitter {
 var MockLoader = _MockLoader;
 MockLoader.EXT_JSON = /\.json5?$/;
 
-// src/parseReqBody.ts
-import bodyParser from "co-body";
-import formidable from "formidable";
-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 bodyParser.json(req);
-    }
-    if (type === "application/x-www-form-urlencoded") {
-      return await bodyParser.form(req);
-    }
-    if (type === "text/plain") {
-      return await bodyParser.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 = formidable(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];
@@ -358,106 +672,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 } = urlParse(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 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 = pathToRegexp(mock.url).test(pathname);
-      if (hasMock && mock.validator) {
-        const urlMatch2 = 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 = 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 = [
@@ -468,8 +689,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",
@@ -479,25 +743,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);
     }
   };
@@ -511,6 +769,7 @@ function defineMock(config) {
 // src/index.ts
 var src_default = mockDevServerPlugin;
 export {
+  baseMiddleware,
   src_default as default,
   defineMock,
   mockDevServerPlugin