rspack-plugin-mock 0.3.0 → 0.3.1

package/dist/{chunk-YSJVV4SH.js → chunk-EY46RSAC.js}

@@ -1,75 +1,3 @@
-// src/core/utils.ts
-import fs from "fs";
-import path from "path";
-import { parse as queryParse } from "querystring";
-import { URL as URL2, fileURLToPath } from "url";
-import os from "os";
-import Debug from "debug";
-import { match } from "path-to-regexp";
-import { Volume, createFsFromVolume } from "memfs";
-var packageDir = getDirname(import.meta.url);
-var vfs = createFsFromVolume(new Volume());
-function isStream(stream) {
-  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
-}
-function isReadableStream(stream) {
-  return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
-}
-function getDirname(importMetaUrl) {
-  return path.dirname(fileURLToPath(importMetaUrl));
-}
-var debug = Debug("rspack:mock");
-function lookupFile(dir, formats, options) {
-  for (const format of formats) {
-    const fullPath = path.join(dir, format);
-    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
-      const result = options?.pathOnly ? fullPath : fs.readFileSync(fullPath, "utf-8");
-      if (!options?.predicate || options.predicate(result))
-        return result;
-    }
-  }
-  const parentDir = path.dirname(dir);
-  if (parentDir !== dir && (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
-    return lookupFile(parentDir, formats, options);
-  }
-}
-function doesProxyContextMatchUrl(context, url, req) {
-  if (typeof context === "function") {
-    return context(url, req);
-  }
-  return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
-}
-function parseParams(pattern, url) {
-  const urlMatch = match(pattern, { decode: decodeURIComponent })(url) || {
-    params: {}
-  };
-  return urlMatch.params || {};
-}
-function urlParse(input) {
-  const url = new URL2(input, "http://example.com");
-  const pathname = decodeURIComponent(url.pathname);
-  const query = queryParse(url.search.replace(/^\?/, ""));
-  return { pathname, query };
-}
-var windowsSlashRE = /\\/g;
-var isWindows = os.platform() === "win32";
-function slash(p) {
-  return p.replace(windowsSlashRE, "/");
-}
-function normalizePath(id) {
-  return path.posix.normalize(isWindows ? slash(id) : id);
-}
-function waitingFor(onSuccess, maxRetry = 5) {
-  return function wait(getter, retry = 0) {
-    const value = getter();
-    if (value) {
-      onSuccess(value);
-    } else if (retry < maxRetry) {
-      setTimeout(() => wait(getter, retry + 1), 100);
-    }
-  };
-}
-
 // src/core/requestRecovery.ts
 import { Buffer } from "buffer";
 var requestCollectCache = /* @__PURE__ */ new WeakMap();
@@ -237,7 +165,7 @@ function matchingWeight(rules, url, priority) {
   const options = special[specialRule];
   const { rules: lowerRules, when } = isArray(options) ? { rules: options, when: [] } : options;
   if (lowerRules.includes(matched[0])) {
-    if (when.length === 0 || when.some((path6) => pathToRegexp(path6).test(url))) {
+    if (when.length === 0 || when.some((path2) => pathToRegexp(path2).test(url))) {
       matched = uniq([specialRule, ...matched]);
     }
   }
@@ -304,6 +232,78 @@ async function parseMultipart(req, options) {
   });
 }
 
+// src/core/utils.ts
+import fs from "fs";
+import path from "path";
+import { parse as queryParse } from "querystring";
+import { URL as URL2, fileURLToPath } from "url";
+import os from "os";
+import Debug from "debug";
+import { match } from "path-to-regexp";
+import { Volume, createFsFromVolume } from "memfs";
+var packageDir = getDirname(import.meta.url);
+var vfs = createFsFromVolume(new Volume());
+function isStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+}
+function isReadableStream(stream) {
+  return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
+}
+function getDirname(importMetaUrl) {
+  return path.dirname(fileURLToPath(importMetaUrl));
+}
+var debug = Debug("rspack:mock");
+function lookupFile(dir, formats, options) {
+  for (const format of formats) {
+    const fullPath = path.join(dir, format);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+      const result = options?.pathOnly ? fullPath : fs.readFileSync(fullPath, "utf-8");
+      if (!options?.predicate || options.predicate(result))
+        return result;
+    }
+  }
+  const parentDir = path.dirname(dir);
+  if (parentDir !== dir && (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
+    return lookupFile(parentDir, formats, options);
+  }
+}
+function doesProxyContextMatchUrl(context, url, req) {
+  if (typeof context === "function") {
+    return context(url, req);
+  }
+  return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
+}
+function parseParams(pattern, url) {
+  const urlMatch = match(pattern, { decode: decodeURIComponent })(url) || {
+    params: {}
+  };
+  return urlMatch.params || {};
+}
+function urlParse(input) {
+  const url = new URL2(input, "http://example.com");
+  const pathname = decodeURIComponent(url.pathname);
+  const query = queryParse(url.search.replace(/^\?/, ""));
+  return { pathname, query };
+}
+var windowsSlashRE = /\\/g;
+var isWindows = os.platform() === "win32";
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return path.posix.normalize(isWindows ? slash(id) : id);
+}
+function waitingFor(onSuccess, maxRetry = 5) {
+  return function wait(getter, retry = 0) {
+    const value = getter();
+    if (value) {
+      onSuccess(value);
+    } else if (retry < maxRetry) {
+      setTimeout(() => wait(getter, retry + 1), 100);
+    }
+  };
+}
+
 // src/core/validator.ts
 import { isArray as isArray2, isObject } from "@pengzhanbo/utils";
 function validate(request, validator) {
@@ -600,50 +600,6 @@ function requestLog(request, filepath) {
   return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
 }
 
-// src/core/mockMiddleware.ts
-import cors from "cors";
-import { pathToRegexp as pathToRegexp3 } from "path-to-regexp";
-function createMockMiddleware(compiler, options) {
-  function mockMiddleware(middlewares, reload) {
-    middlewares.unshift(baseMiddleware(compiler, options));
-    const corsMiddleware = createCorsMiddleware(compiler, options);
-    if (corsMiddleware) {
-      middlewares.unshift(corsMiddleware);
-    }
-    if (options.reload) {
-      compiler.on("update", () => reload?.());
-    }
-    return middlewares;
-  }
-  return mockMiddleware;
-}
-function createCorsMiddleware(compiler, options) {
-  let corsOptions = {};
-  const enabled = options.cors !== false;
-  if (enabled) {
-    corsOptions = {
-      ...corsOptions,
-      ...typeof options.cors === "boolean" ? {} : options.cors
-    };
-  }
-  const proxies = options.proxies;
-  return !enabled ? void 0 : function(req, res, next) {
-    const { pathname } = urlParse(req.url);
-    if (!pathname || proxies.length === 0 || !proxies.some(
-      (context) => doesProxyContextMatchUrl(context, req.url, req)
-    )) {
-      return next();
-    }
-    const mockData = compiler.mockData;
-    const mockUrl = Object.keys(mockData).find(
-      (key) => pathToRegexp3(key).test(pathname)
-    );
-    if (!mockUrl)
-      return next();
-    cors(corsOptions)(req, res, next);
-  };
-}
-
 // src/core/logger.ts
 import { isBoolean } from "@pengzhanbo/utils";
 import colors2 from "picocolors";
@@ -685,67 +641,13 @@ function createLogger(prefix, defaultLevel = "info") {
   return logger;
 }
 
-// src/core/resolvePluginOptions.ts
-import process from "process";
-import { isBoolean as isBoolean2, toArray } from "@pengzhanbo/utils";
-function resolvePluginOptions({
-  prefix = [],
-  wsPrefix = [],
-  cwd,
-  include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"],
-  exclude = ["**/node_modules/**", "**/.vscode/**", "**/.git/**"],
-  reload = false,
-  log = "info",
-  cors: cors2 = true,
-  formidableOptions = {},
-  build = false,
-  cookiesOptions = {},
-  bodyParserOptions = {},
-  priority = {}
-} = {}, { alias, context, plugins, proxies }) {
-  const logger = createLogger(
-    "rspack:mock",
-    isBoolean2(log) ? log ? "info" : "error" : log
-  );
-  return {
-    prefix,
-    wsPrefix,
-    cwd: cwd || context || process.cwd(),
-    include,
-    exclude,
-    reload,
-    cors: cors2,
-    cookiesOptions,
-    log,
-    formidableOptions: {
-      multiples: true,
-      ...formidableOptions
-    },
-    bodyParserOptions,
-    priority,
-    build: build ? Object.assign(
-      {
-        serverPort: 8080,
-        dist: "mockServer",
-        log: "error"
-      },
-      typeof build === "object" ? build : {}
-    ) : false,
-    alias,
-    plugins,
-    proxies,
-    wsProxies: toArray(wsPrefix),
-    logger
-  };
-}
-
 // src/core/transform.ts
 import {
   isEmptyObject as isEmptyObject3,
   isFunction as isFunction2,
   isObject as isObject2,
   sortBy as sortBy2,
-  toArray as toArray2
+  toArray
 } from "@pengzhanbo/utils";
 function transformRawData(rawData) {
   return rawData.filter((item) => item[0]).map(([raw, __filepath__]) => {
@@ -775,7 +677,7 @@ function transformMockData(mockList) {
   const list = [];
   for (const [, handle] of mockList.entries()) {
     if (handle)
-      list.push(...toArray2(handle));
+      list.push(...toArray(handle));
   }
   const mocks = {};
   list.filter((mock) => isObject2(mock) && mock.enabled !== false && mock.url).forEach((mock) => {
@@ -826,433 +728,9 @@ function keysCount(obj) {
   return Object.keys(obj).length;
 }
 
-// src/core/build.ts
-import fs2 from "fs";
-import fsp from "fs/promises";
-import path3 from "path";
-import process2 from "process";
-import fg from "fast-glob";
-import { createFilter } from "@rollup/pluginutils";
-import color2 from "picocolors";
-import { toArray as toArray3 } from "@pengzhanbo/utils";
-
-// src/core/createRspackCompiler.ts
-import path2 from "path";
-import * as rspackCore from "@rspack/core";
-import color from "picocolors";
-import isCore from "is-core-module";
-function createCompiler(options, callback) {
-  const rspackOptions = resolveRspackOptions(options);
-  const isWatch = rspackOptions.watch === true;
-  async function handler(err, stats) {
-    const name = "[rspack:mock]";
-    const logError = stats?.compilation.getLogger(name).error || ((...args) => console.error(color.red(name), ...args));
-    if (err) {
-      logError(err.stack || err);
-      if ("details" in err) {
-        logError(err.details);
-      }
-      return;
-    }
-    if (stats?.hasErrors()) {
-      const info = stats.toJson();
-      logError(info.errors);
-    }
-    const code = vfs.readFileSync("/output.js", "utf-8");
-    const externals = [];
-    if (!isWatch) {
-      const modules = stats?.toJson().modules || [];
-      const aliasList = Object.keys(options.alias || {}).map((key) => key.replace(/\$$/g, ""));
-      for (const { name: name2 } of modules) {
-        if (name2?.startsWith("external")) {
-          const packageName = normalizePackageName(name2);
-          if (!isCore(packageName) && !aliasList.includes(packageName))
-            externals.push(normalizePackageName(name2));
-        }
-      }
-    }
-    await callback({ code, externals });
-  }
-  const compiler = rspackCore.rspack(rspackOptions, isWatch ? handler : void 0);
-  if (compiler)
-    compiler.outputFileSystem = vfs;
-  if (!isWatch) {
-    compiler?.run(async (...args) => {
-      await handler(...args);
-      compiler.close(() => {
-      });
-    });
-  }
-  return compiler;
-}
-function transformWithRspack(options) {
-  return new Promise((resolve) => {
-    createCompiler({ ...options, watch: false }, (result) => {
-      resolve(result);
-    });
-  });
-}
-function normalizePackageName(name) {
-  const filepath = name.replace("external ", "").slice(1, -1);
-  const [scope, packageName] = filepath.split("/");
-  if (filepath[0] === "@") {
-    return `${scope}/${packageName}`;
-  }
-  return scope;
-}
-function resolveRspackOptions({
-  cwd,
-  isEsm = true,
-  entryFile,
-  plugins,
-  alias,
-  watch = false
-}) {
-  const targets = ["node >= 18.0.0"];
-  return {
-    mode: "production",
-    context: cwd,
-    entry: entryFile,
-    watch,
-    target: "node18.0",
-    externalsType: isEsm ? "module" : "commonjs2",
-    externals: /^[^./].*/,
-    resolve: {
-      alias,
-      extensions: [".js", ".ts", ".cjs", ".mjs", ".json5", ".json"]
-    },
-    plugins,
-    output: {
-      library: { type: !isEsm ? "commonjs2" : "module" },
-      filename: "output.js",
-      path: "/"
-    },
-    experiments: { outputModule: isEsm },
-    optimization: { minimize: !watch },
-    module: {
-      rules: [
-        {
-          test: /\.json5?$/,
-          loader: path2.join(packageDir, "json5-loader.cjs"),
-          type: "javascript/auto"
-        },
-        {
-          test: /\.[cm]?js$/,
-          use: [
-            {
-              loader: "builtin:swc-loader",
-              options: {
-                jsc: { parser: { syntax: "ecmascript" } },
-                env: { targets }
-              }
-            }
-          ]
-        },
-        {
-          test: /\.[cm]?ts$/,
-          use: [
-            {
-              loader: "builtin:swc-loader",
-              options: {
-                jsc: { parser: { syntax: "typescript" } },
-                env: { targets }
-              }
-            }
-          ]
-        }
-      ]
-    }
-  };
-}
-
-// src/core/build.ts
-async function buildMockServer(options, outputDir) {
-  const entryFile = path3.resolve(process2.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
-  const mockFileList = await getMockFileList(options);
-  await writeMockEntryFile(entryFile, mockFileList, options.cwd);
-  const { code, externals } = await transformWithRspack({
-    entryFile,
-    cwd: options.cwd,
-    plugins: options.plugins,
-    alias: options.alias
-  });
-  await fsp.unlink(entryFile);
-  const outputList = [
-    { filename: "mock-data.js", source: code },
-    { filename: "index.js", source: generatorServerEntryCode(options) },
-    { filename: "package.json", source: generatePackageJson(options, externals) }
-  ];
-  const dist = path3.resolve(outputDir, options.build.dist);
-  options.logger.info(
-    `${color2.green("\u2713")} generate mock server in ${color2.cyan(path3.relative(process2.cwd(), dist))}`
-  );
-  if (!fs2.existsSync(dist)) {
-    await fsp.mkdir(dist, { recursive: true });
-  }
-  for (const { filename, source } of outputList) {
-    await fsp.writeFile(path3.join(dist, filename), source, "utf8");
-    const sourceSize = (source.length / 1024).toFixed(2);
-    const space = filename.length < 24 ? " ".repeat(24 - filename.length) : "";
-    options.logger.info(` ${color2.green(filename)}${space}${color2.bold(color2.dim(`${sourceSize} kB`))}`);
-  }
-}
-function generatePackageJson(options, externals) {
-  const deps = getHostDependencies(options.cwd);
-  const { name, version } = getPluginPackageInfo();
-  const mockPkg = {
-    name: "mock-server",
-    type: "module",
-    scripts: {
-      start: "node index.js"
-    },
-    dependencies: {
-      connect: "^3.7.0",
-      [name]: `^${version}`,
-      cors: "^2.8.5"
-    }
-  };
-  externals.forEach((dep) => {
-    mockPkg.dependencies[dep] = deps[dep] || "latest";
-  });
-  return JSON.stringify(mockPkg, null, 2);
-}
-function generatorServerEntryCode({
-  proxies,
-  wsPrefix,
-  cookiesOptions,
-  bodyParserOptions,
-  priority,
-  build
-}) {
-  const { serverPort, log } = build;
-  return `import { createServer } from 'node:http';
-import connect from 'connect';
-import corsMiddleware from 'cors';
-import { 
-  baseMiddleware,
-  createLogger,
-  mockWebSocket,
-  transformMockData,
-  transformRawData
-} from 'rspack-plugin-mock';
-import rawData from './mock-data.js';
-
-const app = connect();
-const server = createServer(app);
-const logger = createLogger('mock-server', '${log}');
-const proxies = ${JSON.stringify(proxies)};
-const wsProxies = ${JSON.stringify(toArray3(wsPrefix))};
-const cookiesOptions = ${JSON.stringify(cookiesOptions)};
-const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
-const priority = ${JSON.stringify(priority)};
-const data = { mockData: transformMockData(transformRawData(rawData)) };
-
-mockWebSocket(data, server, { wsProxies, cookiesOptions, logger });
-
-app.use(corsMiddleware());
-app.use(baseMiddleware(data, {
-  formidableOptions: { multiples: true },
-  proxies,
-  priority,
-  cookiesOptions,
-  bodyParserOptions,
-  logger,
-}));
-
-server.listen(${serverPort});
-
-console.log('listen: http://localhost:${serverPort}');
-`;
-}
-async function getMockFileList({ cwd, include, exclude }) {
-  const filter = createFilter(include, exclude, { resolve: false });
-  return await fg(include, { cwd }).then((files) => files.filter(filter));
-}
-async function writeMockEntryFile(entryFile, files, cwd) {
-  const importers = [];
-  const exporters = [];
-  for (const [index, filepath] of files.entries()) {
-    const file = normalizePath(path3.join(cwd, filepath));
-    importers.push(`import * as m${index} from '${file}'`);
-    exporters.push(`[m${index}, '${filepath}']`);
-  }
-  const code = `${importers.join("\n")}
-
-export default [
-  ${exporters.join(",\n  ")}
-]`;
-  const dirname = path3.dirname(entryFile);
-  if (!fs2.existsSync(dirname)) {
-    await fsp.mkdir(dirname, { recursive: true });
-  }
-  await fsp.writeFile(entryFile, code, "utf8");
-}
-function getPluginPackageInfo() {
-  let pkg = {};
-  try {
-    const filepath = path3.join(packageDir, "../package.json");
-    if (fs2.existsSync(filepath)) {
-      pkg = JSON.parse(fs2.readFileSync(filepath, "utf8"));
-    }
-  } catch {
-  }
-  return {
-    name: pkg.name || "rspack-plugin-mock",
-    version: pkg.version || "latest"
-  };
-}
-function getHostDependencies(context) {
-  let pkg = {};
-  try {
-    const content = lookupFile(context, ["package.json"]);
-    if (content)
-      pkg = JSON.parse(content);
-  } catch {
-  }
-  return { ...pkg.dependencies, ...pkg.devDependencies };
-}
-
-// src/core/mockCompiler.ts
-import EventEmitter from "events";
-import process3 from "process";
-import path5 from "path";
-import fastGlob from "fast-glob";
-import chokidar from "chokidar";
-import { createFilter as createFilter2 } from "@rollup/pluginutils";
-import { toArray as toArray4 } from "@pengzhanbo/utils";
-
-// src/core/loadFromCode.ts
-import path4 from "path";
-import fs3, { promises as fsp2 } from "fs";
-async function loadFromCode({
-  filepath,
-  code,
-  isESM,
-  cwd
-}) {
-  filepath = path4.resolve(cwd, filepath);
-  const fileBase = `${filepath}.timestamp-${Date.now()}`;
-  const ext = isESM ? ".mjs" : ".cjs";
-  const fileNameTmp = `${fileBase}${ext}`;
-  await fsp2.writeFile(fileNameTmp, code, "utf8");
-  try {
-    const result = await import(fileNameTmp);
-    return result.default || result;
-  } finally {
-    try {
-      fs3.unlinkSync(fileNameTmp);
-    } catch {
-    }
-  }
-}
-
-// src/core/mockCompiler.ts
-function createMockCompiler(options) {
-  return new MockCompiler(options);
-}
-var MockCompiler = class extends EventEmitter {
-  constructor(options) {
-    super();
-    this.options = options;
-    this.cwd = options.cwd || process3.cwd();
-    const { include, exclude } = this.options;
-    this.fileFilter = createFilter2(include, exclude, { resolve: false });
-    try {
-      const pkg = lookupFile(this.cwd, ["package.json"]);
-      this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
-    } catch {
-    }
-    this.entryFile = path5.resolve(process3.cwd(), "node_modules/.cache/mock-server/mock-server.ts");
-  }
-  cwd;
-  mockWatcher;
-  moduleType = "cjs";
-  entryFile;
-  _mockData = {};
-  fileFilter;
-  watchInfo;
-  compiler;
-  get mockData() {
-    return this._mockData;
-  }
-  async run() {
-    await this.updateMockEntry();
-    this.watchMockFiles();
-    const { plugins, alias } = this.options;
-    const options = {
-      isEsm: this.moduleType === "esm",
-      cwd: this.cwd,
-      plugins,
-      entryFile: this.entryFile,
-      alias,
-      watch: true
-    };
-    this.compiler = createCompiler(options, async ({ code }) => {
-      try {
-        const result = await loadFromCode({
-          filepath: "mock.bundle.js",
-          code,
-          isESM: this.moduleType === "esm",
-          cwd: this.cwd
-        });
-        this._mockData = transformMockData(transformRawData(result));
-        this.emit("update", this.watchInfo || {});
-      } catch (e) {
-        this.options.logger.error(e.stack || e.message);
-      }
-    });
-  }
-  close() {
-    this.mockWatcher.close();
-    this.compiler?.close(() => {
-    });
-    this.emit("close");
-  }
-  updateAlias(alias) {
-    this.options.alias = {
-      ...this.options.alias,
-      ...alias
-    };
-  }
-  async updateMockEntry() {
-    const files = await this.getMockFiles();
-    await writeMockEntryFile(this.entryFile, files, this.cwd);
-  }
-  async getMockFiles() {
-    const { include } = this.options;
-    const files = await fastGlob(include, { cwd: this.cwd });
-    return files.filter(this.fileFilter);
-  }
-  watchMockFiles() {
-    const { include } = this.options;
-    const [firstGlob, ...otherGlob] = toArray4(include);
-    const watcher = this.mockWatcher = chokidar.watch(firstGlob, {
-      ignoreInitial: true,
-      cwd: this.cwd
-    });
-    if (otherGlob.length > 0)
-      otherGlob.forEach((glob) => watcher.add(glob));
-    watcher.on("add", (filepath) => {
-      if (this.fileFilter(filepath)) {
-        this.watchInfo = { filepath, type: "add" };
-        this.updateMockEntry();
-      }
-    });
-    watcher.on("change", (filepath) => {
-      if (this.fileFilter(filepath)) {
-        this.watchInfo = { filepath, type: "change" };
-      }
-    });
-    watcher.on("unlink", async (filepath) => {
-      this.watchInfo = { filepath, type: "unlink" };
-      this.updateMockEntry();
-    });
-  }
-};
-
 // src/core/mockWebsocket.ts
 import Cookies2 from "cookies";
-import { pathToRegexp as pathToRegexp4 } from "path-to-regexp";
+import { pathToRegexp as pathToRegexp3 } from "path-to-regexp";
 import colors3 from "picocolors";
 import { WebSocketServer } from "ws";
 function mockWebSocket(compiler, httpServer, {
@@ -1347,12 +825,12 @@ ${e}
     }
     const mockData = compiler.mockData;
     const mockUrl = Object.keys(mockData).find((key) => {
-      return pathToRegexp4(key).test(pathname);
+      return pathToRegexp3(key).test(pathname);
     });
     if (!mockUrl)
       return;
     const mock = mockData[mockUrl].find((mock2) => {
-      return mock2.url && mock2.ws && pathToRegexp4(mock2.url).test(pathname);
+      return mock2.url && mock2.ws && pathToRegexp3(mock2.url).test(pathname);
     });
     if (!mock)
       return;
@@ -1408,17 +886,19 @@ function cleanupRunner(cleanupList) {
 }
 
 export {
+  packageDir,
+  vfs,
+  lookupFile,
+  doesProxyContextMatchUrl,
+  urlParse,
+  normalizePath,
   waitingFor,
   rewriteRequest,
   baseMiddleware,
-  createMockMiddleware,
   logLevels,
   createLogger,
-  resolvePluginOptions,
   transformRawData,
   transformMockData,
   sortByValidator,
-  buildMockServer,
-  createMockCompiler,
   mockWebSocket
 };